(ForValue.class, this, CoffeeScriptPackage.CLASS_DECLARATION__INDEXES);
+ }
+ return indexes;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ForSource getSource()
+ {
+ return source;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetSource(ForSource newSource, NotificationChain msgs)
+ {
+ ForSource oldSource = source;
+ source = newSource;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__SOURCE, oldSource, newSource);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSource(ForSource newSource)
+ {
+ if (newSource != source)
+ {
+ NotificationChain msgs = null;
+ if (source != null)
+ msgs = ((InternalEObject)source).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__SOURCE, null, msgs);
+ if (newSource != null)
+ msgs = ((InternalEObject)newSource).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__SOURCE, null, msgs);
+ msgs = basicSetSource(newSource, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__SOURCE, newSource, newSource));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EObject getLeft()
+ {
+ return left;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetLeft(EObject newLeft, NotificationChain msgs)
+ {
+ EObject oldLeft = left;
+ left = newLeft;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__LEFT, oldLeft, newLeft);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLeft(EObject newLeft)
+ {
+ if (newLeft != left)
+ {
+ NotificationChain msgs = null;
+ if (left != null)
+ msgs = ((InternalEObject)left).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__LEFT, null, msgs);
+ if (newLeft != null)
+ msgs = ((InternalEObject)newLeft).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__LEFT, null, msgs);
+ msgs = basicSetLeft(newLeft, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__LEFT, newLeft, newLeft));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getOperator()
+ {
+ return operator;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setOperator(String newOperator)
+ {
+ String oldOperator = operator;
+ operator = newOperator;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__OPERATOR, oldOperator, operator));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getRight()
+ {
+ return right;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetRight(Expression newRight, NotificationChain msgs)
+ {
+ Expression oldRight = right;
+ right = newRight;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__RIGHT, oldRight, newRight);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRight(Expression newRight)
+ {
+ if (newRight != right)
+ {
+ NotificationChain msgs = null;
+ if (right != null)
+ msgs = ((InternalEObject)right).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__RIGHT, null, msgs);
+ if (newRight != null)
+ msgs = ((InternalEObject)newRight).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__RIGHT, null, msgs);
+ msgs = basicSetRight(newRight, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__RIGHT, newRight, newRight));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block getBody()
+ {
+ return body;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetBody(Block newBody, NotificationChain msgs)
+ {
+ Block oldBody = body;
+ body = newBody;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__BODY, oldBody, newBody);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setBody(Block newBody)
+ {
+ if (newBody != body)
+ {
+ NotificationChain msgs = null;
+ if (body != null)
+ msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__BODY, null, msgs);
+ if (newBody != null)
+ msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__BODY, null, msgs);
+ msgs = basicSetBody(newBody, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__BODY, newBody, newBody));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public SuperClass getExtend()
+ {
+ return extend;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetExtend(SuperClass newExtend, NotificationChain msgs)
+ {
+ SuperClass oldExtend = extend;
+ extend = newExtend;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__EXTEND, oldExtend, newExtend);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setExtend(SuperClass newExtend)
+ {
+ if (newExtend != extend)
+ {
+ NotificationChain msgs = null;
+ if (extend != null)
+ msgs = ((InternalEObject)extend).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__EXTEND, null, msgs);
+ if (newExtend != null)
+ msgs = ((InternalEObject)newExtend).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__EXTEND, null, msgs);
+ msgs = basicSetExtend(newExtend, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__EXTEND, newExtend, newExtend));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Variable getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetName(Variable newName, NotificationChain msgs)
+ {
+ Variable oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__NAME, oldName, newName);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(Variable newName)
+ {
+ if (newName != name)
+ {
+ NotificationChain msgs = null;
+ if (name != null)
+ msgs = ((InternalEObject)name).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__NAME, null, msgs);
+ if (newName != null)
+ msgs = ((InternalEObject)newName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.CLASS_DECLARATION__NAME, null, msgs);
+ msgs = basicSetName(newName, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.CLASS_DECLARATION__NAME, newName, newName));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.CLASS_DECLARATION__INDEXES:
+ return ((InternalEList)getIndexes()).basicRemove(otherEnd, msgs);
+ case CoffeeScriptPackage.CLASS_DECLARATION__SOURCE:
+ return basicSetSource(null, msgs);
+ case CoffeeScriptPackage.CLASS_DECLARATION__LEFT:
+ return basicSetLeft(null, msgs);
+ case CoffeeScriptPackage.CLASS_DECLARATION__RIGHT:
+ return basicSetRight(null, msgs);
+ case CoffeeScriptPackage.CLASS_DECLARATION__BODY:
+ return basicSetBody(null, msgs);
+ case CoffeeScriptPackage.CLASS_DECLARATION__EXTEND:
+ return basicSetExtend(null, msgs);
+ case CoffeeScriptPackage.CLASS_DECLARATION__NAME:
+ return basicSetName(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.CLASS_DECLARATION__INDEXES:
+ return getIndexes();
+ case CoffeeScriptPackage.CLASS_DECLARATION__SOURCE:
+ return getSource();
+ case CoffeeScriptPackage.CLASS_DECLARATION__LEFT:
+ return getLeft();
+ case CoffeeScriptPackage.CLASS_DECLARATION__OPERATOR:
+ return getOperator();
+ case CoffeeScriptPackage.CLASS_DECLARATION__RIGHT:
+ return getRight();
+ case CoffeeScriptPackage.CLASS_DECLARATION__BODY:
+ return getBody();
+ case CoffeeScriptPackage.CLASS_DECLARATION__EXTEND:
+ return getExtend();
+ case CoffeeScriptPackage.CLASS_DECLARATION__NAME:
+ return getName();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.CLASS_DECLARATION__INDEXES:
+ getIndexes().clear();
+ getIndexes().addAll((Collection)newValue);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__SOURCE:
+ setSource((ForSource)newValue);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__LEFT:
+ setLeft((EObject)newValue);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__OPERATOR:
+ setOperator((String)newValue);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__RIGHT:
+ setRight((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__BODY:
+ setBody((Block)newValue);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__EXTEND:
+ setExtend((SuperClass)newValue);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__NAME:
+ setName((Variable)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.CLASS_DECLARATION__INDEXES:
+ getIndexes().clear();
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__SOURCE:
+ setSource((ForSource)null);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__LEFT:
+ setLeft((EObject)null);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__OPERATOR:
+ setOperator(OPERATOR_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__RIGHT:
+ setRight((Expression)null);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__BODY:
+ setBody((Block)null);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__EXTEND:
+ setExtend((SuperClass)null);
+ return;
+ case CoffeeScriptPackage.CLASS_DECLARATION__NAME:
+ setName((Variable)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.CLASS_DECLARATION__INDEXES:
+ return indexes != null && !indexes.isEmpty();
+ case CoffeeScriptPackage.CLASS_DECLARATION__SOURCE:
+ return source != null;
+ case CoffeeScriptPackage.CLASS_DECLARATION__LEFT:
+ return left != null;
+ case CoffeeScriptPackage.CLASS_DECLARATION__OPERATOR:
+ return OPERATOR_EDEFAULT == null ? operator != null : !OPERATOR_EDEFAULT.equals(operator);
+ case CoffeeScriptPackage.CLASS_DECLARATION__RIGHT:
+ return right != null;
+ case CoffeeScriptPackage.CLASS_DECLARATION__BODY:
+ return body != null;
+ case CoffeeScriptPackage.CLASS_DECLARATION__EXTEND:
+ return extend != null;
+ case CoffeeScriptPackage.CLASS_DECLARATION__NAME:
+ return name != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public int eBaseStructuralFeatureID(int derivedFeatureID, Class baseClass)
+ {
+ if (baseClass == Expression.class)
+ {
+ switch (derivedFeatureID)
+ {
+ case CoffeeScriptPackage.CLASS_DECLARATION__INDEXES: return CoffeeScriptPackage.EXPRESSION__INDEXES;
+ case CoffeeScriptPackage.CLASS_DECLARATION__SOURCE: return CoffeeScriptPackage.EXPRESSION__SOURCE;
+ case CoffeeScriptPackage.CLASS_DECLARATION__LEFT: return CoffeeScriptPackage.EXPRESSION__LEFT;
+ case CoffeeScriptPackage.CLASS_DECLARATION__OPERATOR: return CoffeeScriptPackage.EXPRESSION__OPERATOR;
+ case CoffeeScriptPackage.CLASS_DECLARATION__RIGHT: return CoffeeScriptPackage.EXPRESSION__RIGHT;
+ default: return -1;
+ }
+ }
+ if (baseClass == AssignedClassDeclaration.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public int eDerivedStructuralFeatureID(int baseFeatureID, Class baseClass)
+ {
+ if (baseClass == Expression.class)
+ {
+ switch (baseFeatureID)
+ {
+ case CoffeeScriptPackage.EXPRESSION__INDEXES: return CoffeeScriptPackage.CLASS_DECLARATION__INDEXES;
+ case CoffeeScriptPackage.EXPRESSION__SOURCE: return CoffeeScriptPackage.CLASS_DECLARATION__SOURCE;
+ case CoffeeScriptPackage.EXPRESSION__LEFT: return CoffeeScriptPackage.CLASS_DECLARATION__LEFT;
+ case CoffeeScriptPackage.EXPRESSION__OPERATOR: return CoffeeScriptPackage.CLASS_DECLARATION__OPERATOR;
+ case CoffeeScriptPackage.EXPRESSION__RIGHT: return CoffeeScriptPackage.CLASS_DECLARATION__RIGHT;
+ default: return -1;
+ }
+ }
+ if (baseClass == AssignedClassDeclaration.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (operator: ");
+ result.append(operator);
+ result.append(')');
+ return result.toString();
+ }
+
+} //ClassDeclarationImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/CoffeeScriptFactoryImpl.java b/csep/src-gen/csep/coffeeScript/impl/CoffeeScriptFactoryImpl.java
new file mode 100644
index 0000000..fe82fcc
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/CoffeeScriptFactoryImpl.java
@@ -0,0 +1,886 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.*;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+/**
+ *
+ * An implementation of the model Factory .
+ *
+ * @generated
+ */
+public class CoffeeScriptFactoryImpl extends EFactoryImpl implements CoffeeScriptFactory
+{
+ /**
+ * Creates the default factory implementation.
+ *
+ *
+ * @generated
+ */
+ public static CoffeeScriptFactory init()
+ {
+ try
+ {
+ CoffeeScriptFactory theCoffeeScriptFactory = (CoffeeScriptFactory)EPackage.Registry.INSTANCE.getEFactory("http://www.coffeescript.org/eclipse");
+ if (theCoffeeScriptFactory != null)
+ {
+ return theCoffeeScriptFactory;
+ }
+ }
+ catch (Exception exception)
+ {
+ EcorePlugin.INSTANCE.log(exception);
+ }
+ return new CoffeeScriptFactoryImpl();
+ }
+
+ /**
+ * Creates an instance of the factory.
+ *
+ *
+ * @generated
+ */
+ public CoffeeScriptFactoryImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public EObject create(EClass eClass)
+ {
+ switch (eClass.getClassifierID())
+ {
+ case CoffeeScriptPackage.ROOT: return createRoot();
+ case CoffeeScriptPackage.BODY: return createBody();
+ case CoffeeScriptPackage.LINE: return createLine();
+ case CoffeeScriptPackage.STMT: return createStmt();
+ case CoffeeScriptPackage.COMMENT: return createComment();
+ case CoffeeScriptPackage.REQUIRE_STMT: return createRequireStmt();
+ case CoffeeScriptPackage.RETURN_STMT: return createReturnStmt();
+ case CoffeeScriptPackage.THROW_STMT: return createThrowStmt();
+ case CoffeeScriptPackage.SUPER_CLASS: return createSuperClass();
+ case CoffeeScriptPackage.CLASS_DECLARATION: return createClassDeclaration();
+ case CoffeeScriptPackage.ASSIGNED_CLASS_DECLARATION: return createAssignedClassDeclaration();
+ case CoffeeScriptPackage.EXPRESSION: return createExpression();
+ case CoffeeScriptPackage.FOR_VALUE: return createForValue();
+ case CoffeeScriptPackage.FOR_SOURCE: return createForSource();
+ case CoffeeScriptPackage.RANGE: return createRange();
+ case CoffeeScriptPackage.APPLICATION: return createApplication();
+ case CoffeeScriptPackage.FEATURE_CALL: return createFeatureCall();
+ case CoffeeScriptPackage.FUNCTION_CALL: return createFunctionCall();
+ case CoffeeScriptPackage.PROPERTY_ACCESS: return createPropertyAccess();
+ case CoffeeScriptPackage.THIS_PROPERTY: return createThisProperty();
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS: return createNamedPropertyAccess();
+ case CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS: return createIndexedPropertyAccess();
+ case CoffeeScriptPackage.INDEX: return createIndex();
+ case CoffeeScriptPackage.PRIMARY_EXPRESSION: return createPrimaryExpression();
+ case CoffeeScriptPackage.BLOCK: return createBlock();
+ case CoffeeScriptPackage.CASE: return createCase();
+ case CoffeeScriptPackage.IF_EXP: return createIfExp();
+ case CoffeeScriptPackage.COND_BLOCK: return createCondBlock();
+ case CoffeeScriptPackage.ID_REF: return createIdRef();
+ case CoffeeScriptPackage.ID: return createId();
+ case CoffeeScriptPackage.PROPERTY: return createProperty();
+ case CoffeeScriptPackage.VARIABLE: return createVariable();
+ case CoffeeScriptPackage.ASSIGNABLE_ARRAY: return createAssignableArray();
+ case CoffeeScriptPackage.ASSIGNABLE_ARG_LIST: return createAssignableArgList();
+ case CoffeeScriptPackage.ASSIGNABLE_ARG: return createAssignableArg();
+ case CoffeeScriptPackage.ASSIGNABLE: return createAssignable();
+ case CoffeeScriptPackage.ARG: return createArg();
+ case CoffeeScriptPackage.ARG_LINE: return createArgLine();
+ case CoffeeScriptPackage.EXPLICIT_ARG_LIST: return createExplicitArgList();
+ case CoffeeScriptPackage.ARG_LIST: return createArgList();
+ case CoffeeScriptPackage.ARRAY: return createArray();
+ case CoffeeScriptPackage.DICTIONARY: return createDictionary();
+ case CoffeeScriptPackage.DICT_ITEMS: return createDictItems();
+ case CoffeeScriptPackage.EXPLICIT_DICT_ITEMS: return createExplicitDictItems();
+ case CoffeeScriptPackage.DICT_LINE: return createDictLine();
+ case CoffeeScriptPackage.DICT_ITEM: return createDictItem();
+ case CoffeeScriptPackage.DICT_KEY: return createDictKey();
+ case CoffeeScriptPackage.LAMBDA: return createLambda();
+ case CoffeeScriptPackage.PARAM: return createParam();
+ case CoffeeScriptPackage.NUMBER_LITERAL: return createNumberLiteral();
+ case CoffeeScriptPackage.STRING_LITERAL: return createStringLiteral();
+ case CoffeeScriptPackage.BOOL_LITERAL: return createBoolLiteral();
+ case CoffeeScriptPackage.JS_LITERAL: return createJSLiteral();
+ case CoffeeScriptPackage.REGEX_LITERAL: return createRegexLiteral();
+ case CoffeeScriptPackage.LITERAL: return createLiteral();
+ case CoffeeScriptPackage.PARENTHETICAL: return createParenthetical();
+ case CoffeeScriptPackage.IF: return createIf();
+ case CoffeeScriptPackage.FOR: return createFor();
+ case CoffeeScriptPackage.WHILE: return createWhile();
+ case CoffeeScriptPackage.UNTIL: return createUntil();
+ case CoffeeScriptPackage.BINARY_EXP: return createBinaryExp();
+ case CoffeeScriptPackage.SUPER_CALL: return createSuperCall();
+ case CoffeeScriptPackage.THIS_ALONE: return createThisAlone();
+ case CoffeeScriptPackage.LOOP: return createLoop();
+ case CoffeeScriptPackage.TRY_CATCH: return createTryCatch();
+ case CoffeeScriptPackage.SWITCH: return createSwitch();
+ default:
+ throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+ }
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Root createRoot()
+ {
+ RootImpl root = new RootImpl();
+ return root;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Body createBody()
+ {
+ BodyImpl body = new BodyImpl();
+ return body;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Line createLine()
+ {
+ LineImpl line = new LineImpl();
+ return line;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Stmt createStmt()
+ {
+ StmtImpl stmt = new StmtImpl();
+ return stmt;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Comment createComment()
+ {
+ CommentImpl comment = new CommentImpl();
+ return comment;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public RequireStmt createRequireStmt()
+ {
+ RequireStmtImpl requireStmt = new RequireStmtImpl();
+ return requireStmt;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ReturnStmt createReturnStmt()
+ {
+ ReturnStmtImpl returnStmt = new ReturnStmtImpl();
+ return returnStmt;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ThrowStmt createThrowStmt()
+ {
+ ThrowStmtImpl throwStmt = new ThrowStmtImpl();
+ return throwStmt;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public SuperClass createSuperClass()
+ {
+ SuperClassImpl superClass = new SuperClassImpl();
+ return superClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ClassDeclaration createClassDeclaration()
+ {
+ ClassDeclarationImpl classDeclaration = new ClassDeclarationImpl();
+ return classDeclaration;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public AssignedClassDeclaration createAssignedClassDeclaration()
+ {
+ AssignedClassDeclarationImpl assignedClassDeclaration = new AssignedClassDeclarationImpl();
+ return assignedClassDeclaration;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression createExpression()
+ {
+ ExpressionImpl expression = new ExpressionImpl();
+ return expression;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ForValue createForValue()
+ {
+ ForValueImpl forValue = new ForValueImpl();
+ return forValue;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ForSource createForSource()
+ {
+ ForSourceImpl forSource = new ForSourceImpl();
+ return forSource;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Range createRange()
+ {
+ RangeImpl range = new RangeImpl();
+ return range;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Application createApplication()
+ {
+ ApplicationImpl application = new ApplicationImpl();
+ return application;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public FeatureCall createFeatureCall()
+ {
+ FeatureCallImpl featureCall = new FeatureCallImpl();
+ return featureCall;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public FunctionCall createFunctionCall()
+ {
+ FunctionCallImpl functionCall = new FunctionCallImpl();
+ return functionCall;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public PropertyAccess createPropertyAccess()
+ {
+ PropertyAccessImpl propertyAccess = new PropertyAccessImpl();
+ return propertyAccess;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ThisProperty createThisProperty()
+ {
+ ThisPropertyImpl thisProperty = new ThisPropertyImpl();
+ return thisProperty;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NamedPropertyAccess createNamedPropertyAccess()
+ {
+ NamedPropertyAccessImpl namedPropertyAccess = new NamedPropertyAccessImpl();
+ return namedPropertyAccess;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public IndexedPropertyAccess createIndexedPropertyAccess()
+ {
+ IndexedPropertyAccessImpl indexedPropertyAccess = new IndexedPropertyAccessImpl();
+ return indexedPropertyAccess;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Index createIndex()
+ {
+ IndexImpl index = new IndexImpl();
+ return index;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public PrimaryExpression createPrimaryExpression()
+ {
+ PrimaryExpressionImpl primaryExpression = new PrimaryExpressionImpl();
+ return primaryExpression;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block createBlock()
+ {
+ BlockImpl block = new BlockImpl();
+ return block;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Case createCase()
+ {
+ CaseImpl case_ = new CaseImpl();
+ return case_;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public IfExp createIfExp()
+ {
+ IfExpImpl ifExp = new IfExpImpl();
+ return ifExp;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public CondBlock createCondBlock()
+ {
+ CondBlockImpl condBlock = new CondBlockImpl();
+ return condBlock;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public IdRef createIdRef()
+ {
+ IdRefImpl idRef = new IdRefImpl();
+ return idRef;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Id createId()
+ {
+ IdImpl id = new IdImpl();
+ return id;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Property createProperty()
+ {
+ PropertyImpl property = new PropertyImpl();
+ return property;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Variable createVariable()
+ {
+ VariableImpl variable = new VariableImpl();
+ return variable;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public AssignableArray createAssignableArray()
+ {
+ AssignableArrayImpl assignableArray = new AssignableArrayImpl();
+ return assignableArray;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public AssignableArgList createAssignableArgList()
+ {
+ AssignableArgListImpl assignableArgList = new AssignableArgListImpl();
+ return assignableArgList;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public AssignableArg createAssignableArg()
+ {
+ AssignableArgImpl assignableArg = new AssignableArgImpl();
+ return assignableArg;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Assignable createAssignable()
+ {
+ AssignableImpl assignable = new AssignableImpl();
+ return assignable;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Arg createArg()
+ {
+ ArgImpl arg = new ArgImpl();
+ return arg;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ArgLine createArgLine()
+ {
+ ArgLineImpl argLine = new ArgLineImpl();
+ return argLine;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ExplicitArgList createExplicitArgList()
+ {
+ ExplicitArgListImpl explicitArgList = new ExplicitArgListImpl();
+ return explicitArgList;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ArgList createArgList()
+ {
+ ArgListImpl argList = new ArgListImpl();
+ return argList;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Array createArray()
+ {
+ ArrayImpl array = new ArrayImpl();
+ return array;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Dictionary createDictionary()
+ {
+ DictionaryImpl dictionary = new DictionaryImpl();
+ return dictionary;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public DictItems createDictItems()
+ {
+ DictItemsImpl dictItems = new DictItemsImpl();
+ return dictItems;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ExplicitDictItems createExplicitDictItems()
+ {
+ ExplicitDictItemsImpl explicitDictItems = new ExplicitDictItemsImpl();
+ return explicitDictItems;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public DictLine createDictLine()
+ {
+ DictLineImpl dictLine = new DictLineImpl();
+ return dictLine;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public DictItem createDictItem()
+ {
+ DictItemImpl dictItem = new DictItemImpl();
+ return dictItem;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public DictKey createDictKey()
+ {
+ DictKeyImpl dictKey = new DictKeyImpl();
+ return dictKey;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Lambda createLambda()
+ {
+ LambdaImpl lambda = new LambdaImpl();
+ return lambda;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Param createParam()
+ {
+ ParamImpl param = new ParamImpl();
+ return param;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NumberLiteral createNumberLiteral()
+ {
+ NumberLiteralImpl numberLiteral = new NumberLiteralImpl();
+ return numberLiteral;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public StringLiteral createStringLiteral()
+ {
+ StringLiteralImpl stringLiteral = new StringLiteralImpl();
+ return stringLiteral;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public BoolLiteral createBoolLiteral()
+ {
+ BoolLiteralImpl boolLiteral = new BoolLiteralImpl();
+ return boolLiteral;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public JSLiteral createJSLiteral()
+ {
+ JSLiteralImpl jsLiteral = new JSLiteralImpl();
+ return jsLiteral;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public RegexLiteral createRegexLiteral()
+ {
+ RegexLiteralImpl regexLiteral = new RegexLiteralImpl();
+ return regexLiteral;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Literal createLiteral()
+ {
+ LiteralImpl literal = new LiteralImpl();
+ return literal;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Parenthetical createParenthetical()
+ {
+ ParentheticalImpl parenthetical = new ParentheticalImpl();
+ return parenthetical;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public If createIf()
+ {
+ IfImpl if_ = new IfImpl();
+ return if_;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public For createFor()
+ {
+ ForImpl for_ = new ForImpl();
+ return for_;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public While createWhile()
+ {
+ WhileImpl while_ = new WhileImpl();
+ return while_;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Until createUntil()
+ {
+ UntilImpl until = new UntilImpl();
+ return until;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public BinaryExp createBinaryExp()
+ {
+ BinaryExpImpl binaryExp = new BinaryExpImpl();
+ return binaryExp;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public SuperCall createSuperCall()
+ {
+ SuperCallImpl superCall = new SuperCallImpl();
+ return superCall;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ThisAlone createThisAlone()
+ {
+ ThisAloneImpl thisAlone = new ThisAloneImpl();
+ return thisAlone;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Loop createLoop()
+ {
+ LoopImpl loop = new LoopImpl();
+ return loop;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public TryCatch createTryCatch()
+ {
+ TryCatchImpl tryCatch = new TryCatchImpl();
+ return tryCatch;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Switch createSwitch()
+ {
+ SwitchImpl switch_ = new SwitchImpl();
+ return switch_;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public CoffeeScriptPackage getCoffeeScriptPackage()
+ {
+ return (CoffeeScriptPackage)getEPackage();
+ }
+
+ /**
+ *
+ *
+ * @deprecated
+ * @generated
+ */
+ @Deprecated
+ public static CoffeeScriptPackage getPackage()
+ {
+ return CoffeeScriptPackage.eINSTANCE;
+ }
+
+} //CoffeeScriptFactoryImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/CoffeeScriptPackageImpl.java b/csep/src-gen/csep/coffeeScript/impl/CoffeeScriptPackageImpl.java
new file mode 100644
index 0000000..1eac23d
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/CoffeeScriptPackageImpl.java
@@ -0,0 +1,2748 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Application;
+import csep.coffeeScript.Arg;
+import csep.coffeeScript.ArgLine;
+import csep.coffeeScript.ArgList;
+import csep.coffeeScript.Array;
+import csep.coffeeScript.Assignable;
+import csep.coffeeScript.AssignableArg;
+import csep.coffeeScript.AssignableArgList;
+import csep.coffeeScript.AssignableArray;
+import csep.coffeeScript.AssignedClassDeclaration;
+import csep.coffeeScript.BinaryExp;
+import csep.coffeeScript.Block;
+import csep.coffeeScript.Body;
+import csep.coffeeScript.BoolLiteral;
+import csep.coffeeScript.Case;
+import csep.coffeeScript.ClassDeclaration;
+import csep.coffeeScript.CoffeeScriptFactory;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Comment;
+import csep.coffeeScript.CondBlock;
+import csep.coffeeScript.DictItem;
+import csep.coffeeScript.DictItems;
+import csep.coffeeScript.DictKey;
+import csep.coffeeScript.DictLine;
+import csep.coffeeScript.Dictionary;
+import csep.coffeeScript.ExplicitArgList;
+import csep.coffeeScript.ExplicitDictItems;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.FeatureCall;
+import csep.coffeeScript.For;
+import csep.coffeeScript.ForSource;
+import csep.coffeeScript.ForValue;
+import csep.coffeeScript.FunctionCall;
+import csep.coffeeScript.Id;
+import csep.coffeeScript.IdRef;
+import csep.coffeeScript.If;
+import csep.coffeeScript.IfExp;
+import csep.coffeeScript.Index;
+import csep.coffeeScript.IndexedPropertyAccess;
+import csep.coffeeScript.JSLiteral;
+import csep.coffeeScript.Lambda;
+import csep.coffeeScript.Line;
+import csep.coffeeScript.Literal;
+import csep.coffeeScript.Loop;
+import csep.coffeeScript.NamedPropertyAccess;
+import csep.coffeeScript.NumberLiteral;
+import csep.coffeeScript.Param;
+import csep.coffeeScript.Parenthetical;
+import csep.coffeeScript.PrimaryExpression;
+import csep.coffeeScript.Property;
+import csep.coffeeScript.PropertyAccess;
+import csep.coffeeScript.Range;
+import csep.coffeeScript.RegexLiteral;
+import csep.coffeeScript.RequireStmt;
+import csep.coffeeScript.ReturnStmt;
+import csep.coffeeScript.Root;
+import csep.coffeeScript.Stmt;
+import csep.coffeeScript.StringLiteral;
+import csep.coffeeScript.SuperCall;
+import csep.coffeeScript.SuperClass;
+import csep.coffeeScript.Switch;
+import csep.coffeeScript.ThisAlone;
+import csep.coffeeScript.ThisProperty;
+import csep.coffeeScript.ThrowStmt;
+import csep.coffeeScript.TryCatch;
+import csep.coffeeScript.Until;
+import csep.coffeeScript.Variable;
+import csep.coffeeScript.While;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+/**
+ *
+ * An implementation of the model Package .
+ *
+ * @generated
+ */
+public class CoffeeScriptPackageImpl extends EPackageImpl implements CoffeeScriptPackage
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass rootEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass bodyEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass lineEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass stmtEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass commentEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass requireStmtEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass returnStmtEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass throwStmtEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass superClassEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass classDeclarationEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass assignedClassDeclarationEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass expressionEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass forValueEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass forSourceEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass rangeEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass applicationEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass featureCallEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass functionCallEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass propertyAccessEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass thisPropertyEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass namedPropertyAccessEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass indexedPropertyAccessEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass indexEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass primaryExpressionEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass blockEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass caseEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass ifExpEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass condBlockEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass idRefEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass idEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass propertyEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass variableEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass assignableArrayEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass assignableArgListEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass assignableArgEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass assignableEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass argEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass argLineEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass explicitArgListEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass argListEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass arrayEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass dictionaryEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass dictItemsEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass explicitDictItemsEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass dictLineEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass dictItemEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass dictKeyEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass lambdaEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass paramEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass numberLiteralEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass stringLiteralEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass boolLiteralEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass jsLiteralEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass regexLiteralEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass literalEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass parentheticalEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass ifEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass forEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass whileEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass untilEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass binaryExpEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass superCallEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass thisAloneEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass loopEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass tryCatchEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass switchEClass = null;
+
+ /**
+ * Creates an instance of the model Package , registered with
+ * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+ * package URI value.
+ * Note: the correct way to create the package is via the static
+ * factory method {@link #init init()}, which also performs
+ * initialization of the package, or returns the registered package,
+ * if one already exists.
+ *
+ *
+ * @see org.eclipse.emf.ecore.EPackage.Registry
+ * @see csep.coffeeScript.CoffeeScriptPackage#eNS_URI
+ * @see #init()
+ * @generated
+ */
+ private CoffeeScriptPackageImpl()
+ {
+ super(eNS_URI, CoffeeScriptFactory.eINSTANCE);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private static boolean isInited = false;
+
+ /**
+ * Creates, registers, and initializes the Package for this model, and for any others upon which it depends.
+ *
+ *
This method is used to initialize {@link CoffeeScriptPackage#eINSTANCE} when that field is accessed.
+ * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+ *
+ *
+ * @see #eNS_URI
+ * @see #createPackageContents()
+ * @see #initializePackageContents()
+ * @generated
+ */
+ public static CoffeeScriptPackage init()
+ {
+ if (isInited) return (CoffeeScriptPackage)EPackage.Registry.INSTANCE.getEPackage(CoffeeScriptPackage.eNS_URI);
+
+ // Obtain or create and register package
+ CoffeeScriptPackageImpl theCoffeeScriptPackage = (CoffeeScriptPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof CoffeeScriptPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new CoffeeScriptPackageImpl());
+
+ isInited = true;
+
+ // Create package meta-data objects
+ theCoffeeScriptPackage.createPackageContents();
+
+ // Initialize created meta-data
+ theCoffeeScriptPackage.initializePackageContents();
+
+ // Mark meta-data to indicate it can't be changed
+ theCoffeeScriptPackage.freeze();
+
+
+ // Update the registry and return the package
+ EPackage.Registry.INSTANCE.put(CoffeeScriptPackage.eNS_URI, theCoffeeScriptPackage);
+ return theCoffeeScriptPackage;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getRoot()
+ {
+ return rootEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getBody()
+ {
+ return bodyEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getBody_Lines()
+ {
+ return (EReference)bodyEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getLine()
+ {
+ return lineEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getStmt()
+ {
+ return stmtEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getStmt_Statement()
+ {
+ return (EAttribute)stmtEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getComment()
+ {
+ return commentEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getComment_Comment()
+ {
+ return (EAttribute)commentEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getRequireStmt()
+ {
+ return requireStmtEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getRequireStmt_ImportedNamespace()
+ {
+ return (EReference)requireStmtEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getRequireStmt_Uri()
+ {
+ return (EAttribute)requireStmtEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getReturnStmt()
+ {
+ return returnStmtEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getReturnStmt_Expression()
+ {
+ return (EReference)returnStmtEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getReturnStmt_Condition()
+ {
+ return (EReference)returnStmtEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getThrowStmt()
+ {
+ return throwStmtEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getThrowStmt_Exp()
+ {
+ return (EReference)throwStmtEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getSuperClass()
+ {
+ return superClassEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getClassDeclaration()
+ {
+ return classDeclarationEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getClassDeclaration_Body()
+ {
+ return (EReference)classDeclarationEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getClassDeclaration_Extend()
+ {
+ return (EReference)classDeclarationEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getClassDeclaration_Name()
+ {
+ return (EReference)classDeclarationEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getAssignedClassDeclaration()
+ {
+ return assignedClassDeclarationEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getExpression()
+ {
+ return expressionEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getExpression_Indexes()
+ {
+ return (EReference)expressionEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getExpression_Source()
+ {
+ return (EReference)expressionEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getExpression_Left()
+ {
+ return (EReference)expressionEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getExpression_Operator()
+ {
+ return (EAttribute)expressionEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getExpression_Right()
+ {
+ return (EReference)expressionEClass.getEStructuralFeatures().get(4);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getForValue()
+ {
+ return forValueEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getForSource()
+ {
+ return forSourceEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getForSource_Source()
+ {
+ return (EReference)forSourceEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getForSource_When()
+ {
+ return (EReference)forSourceEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getForSource_By()
+ {
+ return (EReference)forSourceEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getRange()
+ {
+ return rangeEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getRange_Start()
+ {
+ return (EReference)rangeEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getRange_End()
+ {
+ return (EReference)rangeEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getApplication()
+ {
+ return applicationEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getApplication_Value()
+ {
+ return (EReference)applicationEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getApplication_Features()
+ {
+ return (EReference)applicationEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getFeatureCall()
+ {
+ return featureCallEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getFunctionCall()
+ {
+ return functionCallEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getFunctionCall_Args()
+ {
+ return (EReference)functionCallEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getPropertyAccess()
+ {
+ return propertyAccessEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getThisProperty()
+ {
+ return thisPropertyEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getThisProperty_Splat()
+ {
+ return (EAttribute)thisPropertyEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getThisProperty_DefaultValue()
+ {
+ return (EReference)thisPropertyEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getNamedPropertyAccess()
+ {
+ return namedPropertyAccessEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getNamedPropertyAccess_Accessor()
+ {
+ return (EAttribute)namedPropertyAccessEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getNamedPropertyAccess_Name()
+ {
+ return (EReference)namedPropertyAccessEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getIndexedPropertyAccess()
+ {
+ return indexedPropertyAccessEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIndexedPropertyAccess_Index()
+ {
+ return (EReference)indexedPropertyAccessEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getIndex()
+ {
+ return indexEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getIndex_Dots()
+ {
+ return (EAttribute)indexEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIndex_End()
+ {
+ return (EReference)indexEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIndex_Start()
+ {
+ return (EReference)indexEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIndex_Exp()
+ {
+ return (EReference)indexEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getPrimaryExpression()
+ {
+ return primaryExpressionEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getBlock()
+ {
+ return blockEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getCase()
+ {
+ return caseEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getCase_Whens()
+ {
+ return (EReference)caseEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getCase_Then()
+ {
+ return (EReference)caseEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getIfExp()
+ {
+ return ifExpEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIfExp_Blocks()
+ {
+ return (EReference)ifExpEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIfExp_DefaultBlock()
+ {
+ return (EReference)ifExpEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getCondBlock()
+ {
+ return condBlockEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getCondBlock_Operator()
+ {
+ return (EAttribute)condBlockEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getCondBlock_Condition()
+ {
+ return (EReference)condBlockEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getCondBlock_Action()
+ {
+ return (EReference)condBlockEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getIdRef()
+ {
+ return idRefEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIdRef_Val()
+ {
+ return (EReference)idRefEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getIdRef_Accessor()
+ {
+ return (EAttribute)idRefEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIdRef_Prop()
+ {
+ return (EReference)idRefEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIdRef_Index()
+ {
+ return (EReference)idRefEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getId()
+ {
+ return idEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getId_Name()
+ {
+ return (EAttribute)idEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getId_Props()
+ {
+ return (EReference)idEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getProperty()
+ {
+ return propertyEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getVariable()
+ {
+ return variableEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getAssignableArray()
+ {
+ return assignableArrayEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getAssignableArgList()
+ {
+ return assignableArgListEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getAssignableArgList_Args()
+ {
+ return (EReference)assignableArgListEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getAssignableArg()
+ {
+ return assignableArgEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getAssignableArg_Arg()
+ {
+ return (EReference)assignableArgEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getAssignableArg_Splat()
+ {
+ return (EAttribute)assignableArgEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getAssignable()
+ {
+ return assignableEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getArg()
+ {
+ return argEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getArg_Exp()
+ {
+ return (EReference)argEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getArg_Splat()
+ {
+ return (EAttribute)argEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getArgLine()
+ {
+ return argLineEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getArgLine_Head()
+ {
+ return (EReference)argLineEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getArgLine_Tail()
+ {
+ return (EReference)argLineEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getExplicitArgList()
+ {
+ return explicitArgListEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getExplicitArgList_Lines()
+ {
+ return (EReference)explicitArgListEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getArgList()
+ {
+ return argListEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getArgList_Dummy()
+ {
+ return (EReference)argListEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getArray()
+ {
+ return arrayEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getArray_Splat()
+ {
+ return (EAttribute)arrayEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getArray_DefaultValue()
+ {
+ return (EReference)arrayEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getDictionary()
+ {
+ return dictionaryEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getDictionary_Splat()
+ {
+ return (EAttribute)dictionaryEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDictionary_DefaultValue()
+ {
+ return (EReference)dictionaryEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getDictItems()
+ {
+ return dictItemsEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDictItems_Dummy()
+ {
+ return (EReference)dictItemsEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getExplicitDictItems()
+ {
+ return explicitDictItemsEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getExplicitDictItems_Lines()
+ {
+ return (EReference)explicitDictItemsEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getDictLine()
+ {
+ return dictLineEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDictLine_Head()
+ {
+ return (EReference)dictLineEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDictLine_Tail()
+ {
+ return (EReference)dictLineEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getDictItem()
+ {
+ return dictItemEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDictItem_Key()
+ {
+ return (EReference)dictItemEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDictItem_Value()
+ {
+ return (EReference)dictItemEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getDictKey()
+ {
+ return dictKeyEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getLambda()
+ {
+ return lambdaEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getLambda_Params()
+ {
+ return (EReference)lambdaEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getLambda_Body()
+ {
+ return (EReference)lambdaEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getParam()
+ {
+ return paramEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getNumberLiteral()
+ {
+ return numberLiteralEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getStringLiteral()
+ {
+ return stringLiteralEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getBoolLiteral()
+ {
+ return boolLiteralEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getJSLiteral()
+ {
+ return jsLiteralEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getRegexLiteral()
+ {
+ return regexLiteralEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getLiteral()
+ {
+ return literalEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getParenthetical()
+ {
+ return parentheticalEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getParenthetical_Content()
+ {
+ return (EReference)parentheticalEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getIf()
+ {
+ return ifEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIf_Dummy()
+ {
+ return (EReference)ifEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getIf_Condition()
+ {
+ return (EReference)ifEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getFor()
+ {
+ return forEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getFor_Dummy()
+ {
+ return (EReference)forEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getFor_Body()
+ {
+ return (EReference)forEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getFor_Loop()
+ {
+ return (EReference)forEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getWhile()
+ {
+ return whileEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getWhile_Dummy()
+ {
+ return (EReference)whileEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getWhile_Body()
+ {
+ return (EReference)whileEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getWhile_When()
+ {
+ return (EReference)whileEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getWhile_Loop()
+ {
+ return (EReference)whileEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getUntil()
+ {
+ return untilEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getUntil_Dummy()
+ {
+ return (EReference)untilEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getUntil_Body()
+ {
+ return (EReference)untilEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getUntil_When()
+ {
+ return (EReference)untilEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getUntil_Loop()
+ {
+ return (EReference)untilEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getBinaryExp()
+ {
+ return binaryExpEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getSuperCall()
+ {
+ return superCallEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getSuperCall_Args()
+ {
+ return (EReference)superCallEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getThisAlone()
+ {
+ return thisAloneEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getLoop()
+ {
+ return loopEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getLoop_Body()
+ {
+ return (EReference)loopEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getTryCatch()
+ {
+ return tryCatchEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTryCatch_Body()
+ {
+ return (EReference)tryCatchEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTryCatch_Exception()
+ {
+ return (EReference)tryCatchEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTryCatch_CatchBlock()
+ {
+ return (EReference)tryCatchEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTryCatch_FinallyBlock()
+ {
+ return (EReference)tryCatchEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getSwitch()
+ {
+ return switchEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getSwitch_Exp()
+ {
+ return (EReference)switchEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getSwitch_Cases()
+ {
+ return (EReference)switchEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getSwitch_ElseBlock()
+ {
+ return (EReference)switchEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public CoffeeScriptFactory getCoffeeScriptFactory()
+ {
+ return (CoffeeScriptFactory)getEFactoryInstance();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private boolean isCreated = false;
+
+ /**
+ * Creates the meta-model objects for the package. This method is
+ * guarded to have no affect on any invocation but its first.
+ *
+ *
+ * @generated
+ */
+ public void createPackageContents()
+ {
+ if (isCreated) return;
+ isCreated = true;
+
+ // Create classes and their features
+ rootEClass = createEClass(ROOT);
+
+ bodyEClass = createEClass(BODY);
+ createEReference(bodyEClass, BODY__LINES);
+
+ lineEClass = createEClass(LINE);
+
+ stmtEClass = createEClass(STMT);
+ createEAttribute(stmtEClass, STMT__STATEMENT);
+
+ commentEClass = createEClass(COMMENT);
+ createEAttribute(commentEClass, COMMENT__COMMENT);
+
+ requireStmtEClass = createEClass(REQUIRE_STMT);
+ createEReference(requireStmtEClass, REQUIRE_STMT__IMPORTED_NAMESPACE);
+ createEAttribute(requireStmtEClass, REQUIRE_STMT__URI);
+
+ returnStmtEClass = createEClass(RETURN_STMT);
+ createEReference(returnStmtEClass, RETURN_STMT__EXPRESSION);
+ createEReference(returnStmtEClass, RETURN_STMT__CONDITION);
+
+ throwStmtEClass = createEClass(THROW_STMT);
+ createEReference(throwStmtEClass, THROW_STMT__EXP);
+
+ superClassEClass = createEClass(SUPER_CLASS);
+
+ classDeclarationEClass = createEClass(CLASS_DECLARATION);
+ createEReference(classDeclarationEClass, CLASS_DECLARATION__BODY);
+ createEReference(classDeclarationEClass, CLASS_DECLARATION__EXTEND);
+ createEReference(classDeclarationEClass, CLASS_DECLARATION__NAME);
+
+ assignedClassDeclarationEClass = createEClass(ASSIGNED_CLASS_DECLARATION);
+
+ expressionEClass = createEClass(EXPRESSION);
+ createEReference(expressionEClass, EXPRESSION__INDEXES);
+ createEReference(expressionEClass, EXPRESSION__SOURCE);
+ createEReference(expressionEClass, EXPRESSION__LEFT);
+ createEAttribute(expressionEClass, EXPRESSION__OPERATOR);
+ createEReference(expressionEClass, EXPRESSION__RIGHT);
+
+ forValueEClass = createEClass(FOR_VALUE);
+
+ forSourceEClass = createEClass(FOR_SOURCE);
+ createEReference(forSourceEClass, FOR_SOURCE__SOURCE);
+ createEReference(forSourceEClass, FOR_SOURCE__WHEN);
+ createEReference(forSourceEClass, FOR_SOURCE__BY);
+
+ rangeEClass = createEClass(RANGE);
+ createEReference(rangeEClass, RANGE__START);
+ createEReference(rangeEClass, RANGE__END);
+
+ applicationEClass = createEClass(APPLICATION);
+ createEReference(applicationEClass, APPLICATION__VALUE);
+ createEReference(applicationEClass, APPLICATION__FEATURES);
+
+ featureCallEClass = createEClass(FEATURE_CALL);
+
+ functionCallEClass = createEClass(FUNCTION_CALL);
+ createEReference(functionCallEClass, FUNCTION_CALL__ARGS);
+
+ propertyAccessEClass = createEClass(PROPERTY_ACCESS);
+
+ thisPropertyEClass = createEClass(THIS_PROPERTY);
+ createEAttribute(thisPropertyEClass, THIS_PROPERTY__SPLAT);
+ createEReference(thisPropertyEClass, THIS_PROPERTY__DEFAULT_VALUE);
+
+ namedPropertyAccessEClass = createEClass(NAMED_PROPERTY_ACCESS);
+ createEAttribute(namedPropertyAccessEClass, NAMED_PROPERTY_ACCESS__ACCESSOR);
+ createEReference(namedPropertyAccessEClass, NAMED_PROPERTY_ACCESS__NAME);
+
+ indexedPropertyAccessEClass = createEClass(INDEXED_PROPERTY_ACCESS);
+ createEReference(indexedPropertyAccessEClass, INDEXED_PROPERTY_ACCESS__INDEX);
+
+ indexEClass = createEClass(INDEX);
+ createEAttribute(indexEClass, INDEX__DOTS);
+ createEReference(indexEClass, INDEX__END);
+ createEReference(indexEClass, INDEX__START);
+ createEReference(indexEClass, INDEX__EXP);
+
+ primaryExpressionEClass = createEClass(PRIMARY_EXPRESSION);
+
+ blockEClass = createEClass(BLOCK);
+
+ caseEClass = createEClass(CASE);
+ createEReference(caseEClass, CASE__WHENS);
+ createEReference(caseEClass, CASE__THEN);
+
+ ifExpEClass = createEClass(IF_EXP);
+ createEReference(ifExpEClass, IF_EXP__BLOCKS);
+ createEReference(ifExpEClass, IF_EXP__DEFAULT_BLOCK);
+
+ condBlockEClass = createEClass(COND_BLOCK);
+ createEAttribute(condBlockEClass, COND_BLOCK__OPERATOR);
+ createEReference(condBlockEClass, COND_BLOCK__CONDITION);
+ createEReference(condBlockEClass, COND_BLOCK__ACTION);
+
+ idRefEClass = createEClass(ID_REF);
+ createEReference(idRefEClass, ID_REF__VAL);
+ createEAttribute(idRefEClass, ID_REF__ACCESSOR);
+ createEReference(idRefEClass, ID_REF__PROP);
+ createEReference(idRefEClass, ID_REF__INDEX);
+
+ idEClass = createEClass(ID);
+ createEAttribute(idEClass, ID__NAME);
+ createEReference(idEClass, ID__PROPS);
+
+ propertyEClass = createEClass(PROPERTY);
+
+ variableEClass = createEClass(VARIABLE);
+
+ assignableArrayEClass = createEClass(ASSIGNABLE_ARRAY);
+
+ assignableArgListEClass = createEClass(ASSIGNABLE_ARG_LIST);
+ createEReference(assignableArgListEClass, ASSIGNABLE_ARG_LIST__ARGS);
+
+ assignableArgEClass = createEClass(ASSIGNABLE_ARG);
+ createEReference(assignableArgEClass, ASSIGNABLE_ARG__ARG);
+ createEAttribute(assignableArgEClass, ASSIGNABLE_ARG__SPLAT);
+
+ assignableEClass = createEClass(ASSIGNABLE);
+
+ argEClass = createEClass(ARG);
+ createEReference(argEClass, ARG__EXP);
+ createEAttribute(argEClass, ARG__SPLAT);
+
+ argLineEClass = createEClass(ARG_LINE);
+ createEReference(argLineEClass, ARG_LINE__HEAD);
+ createEReference(argLineEClass, ARG_LINE__TAIL);
+
+ explicitArgListEClass = createEClass(EXPLICIT_ARG_LIST);
+ createEReference(explicitArgListEClass, EXPLICIT_ARG_LIST__LINES);
+
+ argListEClass = createEClass(ARG_LIST);
+ createEReference(argListEClass, ARG_LIST__DUMMY);
+
+ arrayEClass = createEClass(ARRAY);
+ createEAttribute(arrayEClass, ARRAY__SPLAT);
+ createEReference(arrayEClass, ARRAY__DEFAULT_VALUE);
+
+ dictionaryEClass = createEClass(DICTIONARY);
+ createEAttribute(dictionaryEClass, DICTIONARY__SPLAT);
+ createEReference(dictionaryEClass, DICTIONARY__DEFAULT_VALUE);
+
+ dictItemsEClass = createEClass(DICT_ITEMS);
+ createEReference(dictItemsEClass, DICT_ITEMS__DUMMY);
+
+ explicitDictItemsEClass = createEClass(EXPLICIT_DICT_ITEMS);
+ createEReference(explicitDictItemsEClass, EXPLICIT_DICT_ITEMS__LINES);
+
+ dictLineEClass = createEClass(DICT_LINE);
+ createEReference(dictLineEClass, DICT_LINE__HEAD);
+ createEReference(dictLineEClass, DICT_LINE__TAIL);
+
+ dictItemEClass = createEClass(DICT_ITEM);
+ createEReference(dictItemEClass, DICT_ITEM__KEY);
+ createEReference(dictItemEClass, DICT_ITEM__VALUE);
+
+ dictKeyEClass = createEClass(DICT_KEY);
+
+ lambdaEClass = createEClass(LAMBDA);
+ createEReference(lambdaEClass, LAMBDA__PARAMS);
+ createEReference(lambdaEClass, LAMBDA__BODY);
+
+ paramEClass = createEClass(PARAM);
+
+ numberLiteralEClass = createEClass(NUMBER_LITERAL);
+
+ stringLiteralEClass = createEClass(STRING_LITERAL);
+
+ boolLiteralEClass = createEClass(BOOL_LITERAL);
+
+ jsLiteralEClass = createEClass(JS_LITERAL);
+
+ regexLiteralEClass = createEClass(REGEX_LITERAL);
+
+ literalEClass = createEClass(LITERAL);
+
+ parentheticalEClass = createEClass(PARENTHETICAL);
+ createEReference(parentheticalEClass, PARENTHETICAL__CONTENT);
+
+ ifEClass = createEClass(IF);
+ createEReference(ifEClass, IF__DUMMY);
+ createEReference(ifEClass, IF__CONDITION);
+
+ forEClass = createEClass(FOR);
+ createEReference(forEClass, FOR__DUMMY);
+ createEReference(forEClass, FOR__BODY);
+ createEReference(forEClass, FOR__LOOP);
+
+ whileEClass = createEClass(WHILE);
+ createEReference(whileEClass, WHILE__DUMMY);
+ createEReference(whileEClass, WHILE__BODY);
+ createEReference(whileEClass, WHILE__WHEN);
+ createEReference(whileEClass, WHILE__LOOP);
+
+ untilEClass = createEClass(UNTIL);
+ createEReference(untilEClass, UNTIL__DUMMY);
+ createEReference(untilEClass, UNTIL__BODY);
+ createEReference(untilEClass, UNTIL__WHEN);
+ createEReference(untilEClass, UNTIL__LOOP);
+
+ binaryExpEClass = createEClass(BINARY_EXP);
+
+ superCallEClass = createEClass(SUPER_CALL);
+ createEReference(superCallEClass, SUPER_CALL__ARGS);
+
+ thisAloneEClass = createEClass(THIS_ALONE);
+
+ loopEClass = createEClass(LOOP);
+ createEReference(loopEClass, LOOP__BODY);
+
+ tryCatchEClass = createEClass(TRY_CATCH);
+ createEReference(tryCatchEClass, TRY_CATCH__BODY);
+ createEReference(tryCatchEClass, TRY_CATCH__EXCEPTION);
+ createEReference(tryCatchEClass, TRY_CATCH__CATCH_BLOCK);
+ createEReference(tryCatchEClass, TRY_CATCH__FINALLY_BLOCK);
+
+ switchEClass = createEClass(SWITCH);
+ createEReference(switchEClass, SWITCH__EXP);
+ createEReference(switchEClass, SWITCH__CASES);
+ createEReference(switchEClass, SWITCH__ELSE_BLOCK);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private boolean isInitialized = false;
+
+ /**
+ * Complete the initialization of the package and its meta-model. This
+ * method is guarded to have no affect on any invocation but its first.
+ *
+ *
+ * @generated
+ */
+ public void initializePackageContents()
+ {
+ if (isInitialized) return;
+ isInitialized = true;
+
+ // Initialize package
+ setName(eNAME);
+ setNsPrefix(eNS_PREFIX);
+ setNsURI(eNS_URI);
+
+ // Create type parameters
+
+ // Set bounds for type parameters
+
+ // Add supertypes to classes
+ bodyEClass.getESuperTypes().add(this.getRoot());
+ bodyEClass.getESuperTypes().add(this.getBlock());
+ stmtEClass.getESuperTypes().add(this.getLine());
+ commentEClass.getESuperTypes().add(this.getStmt());
+ requireStmtEClass.getESuperTypes().add(this.getStmt());
+ returnStmtEClass.getESuperTypes().add(this.getStmt());
+ throwStmtEClass.getESuperTypes().add(this.getStmt());
+ classDeclarationEClass.getESuperTypes().add(this.getStmt());
+ classDeclarationEClass.getESuperTypes().add(this.getAssignedClassDeclaration());
+ assignedClassDeclarationEClass.getESuperTypes().add(this.getExpression());
+ expressionEClass.getESuperTypes().add(this.getLine());
+ rangeEClass.getESuperTypes().add(this.getPrimaryExpression());
+ applicationEClass.getESuperTypes().add(this.getExpression());
+ functionCallEClass.getESuperTypes().add(this.getFeatureCall());
+ propertyAccessEClass.getESuperTypes().add(this.getFeatureCall());
+ thisPropertyEClass.getESuperTypes().add(this.getPrimaryExpression());
+ thisPropertyEClass.getESuperTypes().add(this.getParam());
+ namedPropertyAccessEClass.getESuperTypes().add(this.getPropertyAccess());
+ indexedPropertyAccessEClass.getESuperTypes().add(this.getPropertyAccess());
+ blockEClass.getESuperTypes().add(this.getRoot());
+ ifExpEClass.getESuperTypes().add(this.getPrimaryExpression());
+ idRefEClass.getESuperTypes().add(this.getSuperClass());
+ idRefEClass.getESuperTypes().add(this.getPrimaryExpression());
+ idRefEClass.getESuperTypes().add(this.getProperty());
+ idEClass.getESuperTypes().add(this.getForValue());
+ idEClass.getESuperTypes().add(this.getThisProperty());
+ idEClass.getESuperTypes().add(this.getVariable());
+ idEClass.getESuperTypes().add(this.getDictKey());
+ idEClass.getESuperTypes().add(this.getParam());
+ propertyEClass.getESuperTypes().add(this.getSuperClass());
+ propertyEClass.getESuperTypes().add(this.getVariable());
+ variableEClass.getESuperTypes().add(this.getExpression());
+ variableEClass.getESuperTypes().add(this.getAssignable());
+ assignableArrayEClass.getESuperTypes().add(this.getAssignable());
+ assignableArgListEClass.getESuperTypes().add(this.getAssignableArray());
+ argListEClass.getESuperTypes().add(this.getArray());
+ arrayEClass.getESuperTypes().add(this.getPrimaryExpression());
+ arrayEClass.getESuperTypes().add(this.getParam());
+ dictionaryEClass.getESuperTypes().add(this.getPrimaryExpression());
+ dictionaryEClass.getESuperTypes().add(this.getAssignable());
+ dictionaryEClass.getESuperTypes().add(this.getParam());
+ dictItemsEClass.getESuperTypes().add(this.getDictionary());
+ lambdaEClass.getESuperTypes().add(this.getPrimaryExpression());
+ numberLiteralEClass.getESuperTypes().add(this.getLiteral());
+ stringLiteralEClass.getESuperTypes().add(this.getLiteral());
+ boolLiteralEClass.getESuperTypes().add(this.getLiteral());
+ jsLiteralEClass.getESuperTypes().add(this.getLiteral());
+ regexLiteralEClass.getESuperTypes().add(this.getLiteral());
+ literalEClass.getESuperTypes().add(this.getPrimaryExpression());
+ literalEClass.getESuperTypes().add(this.getDictKey());
+ parentheticalEClass.getESuperTypes().add(this.getPrimaryExpression());
+ ifEClass.getESuperTypes().add(this.getExpression());
+ forEClass.getESuperTypes().add(this.getExpression());
+ forEClass.getESuperTypes().add(this.getPrimaryExpression());
+ whileEClass.getESuperTypes().add(this.getExpression());
+ whileEClass.getESuperTypes().add(this.getPrimaryExpression());
+ untilEClass.getESuperTypes().add(this.getExpression());
+ untilEClass.getESuperTypes().add(this.getPrimaryExpression());
+ binaryExpEClass.getESuperTypes().add(this.getExpression());
+ superCallEClass.getESuperTypes().add(this.getApplication());
+ thisAloneEClass.getESuperTypes().add(this.getPrimaryExpression());
+ loopEClass.getESuperTypes().add(this.getPrimaryExpression());
+ tryCatchEClass.getESuperTypes().add(this.getPrimaryExpression());
+ switchEClass.getESuperTypes().add(this.getPrimaryExpression());
+
+ // Initialize classes and features; add operations and parameters
+ initEClass(rootEClass, Root.class, "Root", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(bodyEClass, Body.class, "Body", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getBody_Lines(), this.getLine(), null, "lines", null, 0, -1, Body.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(lineEClass, Line.class, "Line", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(stmtEClass, Stmt.class, "Stmt", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getStmt_Statement(), ecorePackage.getEString(), "statement", null, 0, 1, Stmt.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(commentEClass, Comment.class, "Comment", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getComment_Comment(), ecorePackage.getEString(), "comment", null, 0, 1, Comment.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(requireStmtEClass, RequireStmt.class, "RequireStmt", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getRequireStmt_ImportedNamespace(), this.getId(), null, "importedNamespace", null, 0, 1, RequireStmt.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getRequireStmt_Uri(), ecorePackage.getEString(), "uri", null, 0, 1, RequireStmt.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(returnStmtEClass, ReturnStmt.class, "ReturnStmt", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getReturnStmt_Expression(), this.getExpression(), null, "expression", null, 0, 1, ReturnStmt.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getReturnStmt_Condition(), this.getExpression(), null, "condition", null, 0, 1, ReturnStmt.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(throwStmtEClass, ThrowStmt.class, "ThrowStmt", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getThrowStmt_Exp(), this.getExpression(), null, "exp", null, 0, 1, ThrowStmt.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(superClassEClass, SuperClass.class, "SuperClass", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(classDeclarationEClass, ClassDeclaration.class, "ClassDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getClassDeclaration_Body(), this.getBlock(), null, "body", null, 0, 1, ClassDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getClassDeclaration_Extend(), this.getSuperClass(), null, "extend", null, 0, 1, ClassDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getClassDeclaration_Name(), this.getVariable(), null, "name", null, 0, 1, ClassDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(assignedClassDeclarationEClass, AssignedClassDeclaration.class, "AssignedClassDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(expressionEClass, Expression.class, "Expression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getExpression_Indexes(), this.getForValue(), null, "indexes", null, 0, -1, Expression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getExpression_Source(), this.getForSource(), null, "source", null, 0, 1, Expression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getExpression_Left(), ecorePackage.getEObject(), null, "left", null, 0, 1, Expression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getExpression_Operator(), ecorePackage.getEString(), "operator", null, 0, 1, Expression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getExpression_Right(), this.getExpression(), null, "right", null, 0, 1, Expression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(forValueEClass, ForValue.class, "ForValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(forSourceEClass, ForSource.class, "ForSource", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getForSource_Source(), this.getExpression(), null, "source", null, 0, 1, ForSource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getForSource_When(), this.getExpression(), null, "when", null, 0, 1, ForSource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getForSource_By(), this.getExpression(), null, "by", null, 0, 1, ForSource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(rangeEClass, Range.class, "Range", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getRange_Start(), this.getExpression(), null, "start", null, 0, 1, Range.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getRange_End(), this.getExpression(), null, "end", null, 0, 1, Range.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(applicationEClass, Application.class, "Application", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getApplication_Value(), this.getPrimaryExpression(), null, "value", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getApplication_Features(), this.getFeatureCall(), null, "features", null, 0, -1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(featureCallEClass, FeatureCall.class, "FeatureCall", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(functionCallEClass, FunctionCall.class, "FunctionCall", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getFunctionCall_Args(), this.getArgList(), null, "args", null, 0, 1, FunctionCall.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(propertyAccessEClass, PropertyAccess.class, "PropertyAccess", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(thisPropertyEClass, ThisProperty.class, "ThisProperty", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getThisProperty_Splat(), ecorePackage.getEBoolean(), "splat", null, 0, 1, ThisProperty.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getThisProperty_DefaultValue(), this.getExpression(), null, "defaultValue", null, 0, 1, ThisProperty.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(namedPropertyAccessEClass, NamedPropertyAccess.class, "NamedPropertyAccess", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getNamedPropertyAccess_Accessor(), ecorePackage.getEString(), "accessor", null, 0, 1, NamedPropertyAccess.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getNamedPropertyAccess_Name(), this.getId(), null, "name", null, 0, 1, NamedPropertyAccess.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(indexedPropertyAccessEClass, IndexedPropertyAccess.class, "IndexedPropertyAccess", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getIndexedPropertyAccess_Index(), this.getIndex(), null, "index", null, 0, 1, IndexedPropertyAccess.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(indexEClass, Index.class, "Index", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getIndex_Dots(), ecorePackage.getEString(), "dots", null, 0, 1, Index.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getIndex_End(), this.getExpression(), null, "end", null, 0, 1, Index.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getIndex_Start(), this.getExpression(), null, "start", null, 0, 1, Index.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getIndex_Exp(), this.getExpression(), null, "exp", null, 0, 1, Index.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(primaryExpressionEClass, PrimaryExpression.class, "PrimaryExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(blockEClass, Block.class, "Block", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(caseEClass, Case.class, "Case", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getCase_Whens(), this.getExpression(), null, "whens", null, 0, -1, Case.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getCase_Then(), this.getBlock(), null, "then", null, 0, 1, Case.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(ifExpEClass, IfExp.class, "IfExp", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getIfExp_Blocks(), this.getCondBlock(), null, "blocks", null, 0, -1, IfExp.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getIfExp_DefaultBlock(), this.getBlock(), null, "defaultBlock", null, 0, 1, IfExp.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(condBlockEClass, CondBlock.class, "CondBlock", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getCondBlock_Operator(), ecorePackage.getEString(), "operator", null, 0, 1, CondBlock.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getCondBlock_Condition(), this.getExpression(), null, "condition", null, 0, 1, CondBlock.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getCondBlock_Action(), this.getBlock(), null, "action", null, 0, 1, CondBlock.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(idRefEClass, IdRef.class, "IdRef", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getIdRef_Val(), this.getId(), null, "val", null, 0, 1, IdRef.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getIdRef_Accessor(), ecorePackage.getEString(), "accessor", null, 0, 1, IdRef.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getIdRef_Prop(), this.getId(), null, "prop", null, 0, 1, IdRef.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getIdRef_Index(), this.getIndex(), null, "index", null, 0, 1, IdRef.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(idEClass, Id.class, "Id", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getId_Name(), ecorePackage.getEString(), "name", null, 0, 1, Id.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getId_Props(), this.getId(), null, "props", null, 0, -1, Id.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(propertyEClass, Property.class, "Property", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(variableEClass, Variable.class, "Variable", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(assignableArrayEClass, AssignableArray.class, "AssignableArray", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(assignableArgListEClass, AssignableArgList.class, "AssignableArgList", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getAssignableArgList_Args(), this.getAssignableArg(), null, "args", null, 0, -1, AssignableArgList.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(assignableArgEClass, AssignableArg.class, "AssignableArg", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getAssignableArg_Arg(), this.getAssignable(), null, "arg", null, 0, 1, AssignableArg.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getAssignableArg_Splat(), ecorePackage.getEBoolean(), "splat", null, 0, 1, AssignableArg.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(assignableEClass, Assignable.class, "Assignable", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(argEClass, Arg.class, "Arg", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getArg_Exp(), this.getExpression(), null, "exp", null, 0, 1, Arg.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getArg_Splat(), ecorePackage.getEBoolean(), "splat", null, 0, 1, Arg.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(argLineEClass, ArgLine.class, "ArgLine", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getArgLine_Head(), this.getArg(), null, "head", null, 0, 1, ArgLine.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getArgLine_Tail(), this.getArg(), null, "tail", null, 0, -1, ArgLine.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(explicitArgListEClass, ExplicitArgList.class, "ExplicitArgList", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getExplicitArgList_Lines(), this.getArgLine(), null, "lines", null, 0, -1, ExplicitArgList.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(argListEClass, ArgList.class, "ArgList", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getArgList_Dummy(), this.getExplicitArgList(), null, "dummy", null, 0, 1, ArgList.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(arrayEClass, Array.class, "Array", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getArray_Splat(), ecorePackage.getEBoolean(), "splat", null, 0, 1, Array.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getArray_DefaultValue(), this.getExpression(), null, "defaultValue", null, 0, 1, Array.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(dictionaryEClass, Dictionary.class, "Dictionary", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getDictionary_Splat(), ecorePackage.getEBoolean(), "splat", null, 0, 1, Dictionary.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getDictionary_DefaultValue(), this.getExpression(), null, "defaultValue", null, 0, 1, Dictionary.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(dictItemsEClass, DictItems.class, "DictItems", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getDictItems_Dummy(), this.getExplicitDictItems(), null, "dummy", null, 0, 1, DictItems.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(explicitDictItemsEClass, ExplicitDictItems.class, "ExplicitDictItems", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getExplicitDictItems_Lines(), this.getDictLine(), null, "lines", null, 0, -1, ExplicitDictItems.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(dictLineEClass, DictLine.class, "DictLine", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getDictLine_Head(), this.getDictItem(), null, "head", null, 0, 1, DictLine.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getDictLine_Tail(), this.getDictItem(), null, "tail", null, 0, -1, DictLine.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(dictItemEClass, DictItem.class, "DictItem", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getDictItem_Key(), this.getDictKey(), null, "key", null, 0, 1, DictItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getDictItem_Value(), this.getExpression(), null, "value", null, 0, 1, DictItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(dictKeyEClass, DictKey.class, "DictKey", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(lambdaEClass, Lambda.class, "Lambda", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getLambda_Params(), this.getParam(), null, "params", null, 0, -1, Lambda.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getLambda_Body(), this.getBlock(), null, "body", null, 0, 1, Lambda.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(paramEClass, Param.class, "Param", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(numberLiteralEClass, NumberLiteral.class, "NumberLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(stringLiteralEClass, StringLiteral.class, "StringLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(boolLiteralEClass, BoolLiteral.class, "BoolLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(jsLiteralEClass, JSLiteral.class, "JSLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(regexLiteralEClass, RegexLiteral.class, "RegexLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(literalEClass, Literal.class, "Literal", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(parentheticalEClass, Parenthetical.class, "Parenthetical", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getParenthetical_Content(), this.getBody(), null, "content", null, 0, 1, Parenthetical.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(ifEClass, If.class, "If", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getIf_Dummy(), this.getExpression(), null, "dummy", null, 0, 1, If.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getIf_Condition(), this.getExpression(), null, "condition", null, 0, 1, If.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(forEClass, For.class, "For", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getFor_Dummy(), this.getExpression(), null, "dummy", null, 0, 1, For.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getFor_Body(), ecorePackage.getEObject(), null, "body", null, 0, 1, For.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getFor_Loop(), this.getExpression(), null, "loop", null, 0, 1, For.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(whileEClass, While.class, "While", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getWhile_Dummy(), this.getExpression(), null, "dummy", null, 0, 1, While.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getWhile_Body(), ecorePackage.getEObject(), null, "body", null, 0, 1, While.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getWhile_When(), this.getExpression(), null, "when", null, 0, 1, While.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getWhile_Loop(), this.getExpression(), null, "loop", null, 0, 1, While.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(untilEClass, Until.class, "Until", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getUntil_Dummy(), this.getExpression(), null, "dummy", null, 0, 1, Until.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getUntil_Body(), ecorePackage.getEObject(), null, "body", null, 0, 1, Until.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getUntil_When(), this.getExpression(), null, "when", null, 0, 1, Until.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getUntil_Loop(), this.getExpression(), null, "loop", null, 0, 1, Until.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(binaryExpEClass, BinaryExp.class, "BinaryExp", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(superCallEClass, SuperCall.class, "SuperCall", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getSuperCall_Args(), this.getArgList(), null, "args", null, 0, 1, SuperCall.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(thisAloneEClass, ThisAlone.class, "ThisAlone", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(loopEClass, Loop.class, "Loop", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getLoop_Body(), this.getBlock(), null, "body", null, 0, 1, Loop.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(tryCatchEClass, TryCatch.class, "TryCatch", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getTryCatch_Body(), this.getBlock(), null, "body", null, 0, 1, TryCatch.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTryCatch_Exception(), this.getId(), null, "exception", null, 0, 1, TryCatch.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTryCatch_CatchBlock(), this.getBlock(), null, "catchBlock", null, 0, 1, TryCatch.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTryCatch_FinallyBlock(), this.getBlock(), null, "finallyBlock", null, 0, 1, TryCatch.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(switchEClass, Switch.class, "Switch", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getSwitch_Exp(), this.getExpression(), null, "exp", null, 0, 1, Switch.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getSwitch_Cases(), this.getCase(), null, "cases", null, 0, -1, Switch.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getSwitch_ElseBlock(), this.getBlock(), null, "elseBlock", null, 0, 1, Switch.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ // Create resource
+ createResource(eNS_URI);
+ }
+
+} //CoffeeScriptPackageImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/CommentImpl.java b/csep/src-gen/csep/coffeeScript/impl/CommentImpl.java
new file mode 100644
index 0000000..86558b2
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/CommentImpl.java
@@ -0,0 +1,176 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Comment;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Comment
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.CommentImpl#getComment Comment }
+ *
+ *
+ *
+ * @generated
+ */
+public class CommentImpl extends StmtImpl implements Comment
+{
+ /**
+ * The default value of the '{@link #getComment() Comment }' attribute.
+ *
+ *
+ * @see #getComment()
+ * @generated
+ * @ordered
+ */
+ protected static final String COMMENT_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getComment() Comment }' attribute.
+ *
+ *
+ * @see #getComment()
+ * @generated
+ * @ordered
+ */
+ protected String comment = COMMENT_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected CommentImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.COMMENT;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getComment()
+ {
+ return comment;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setComment(String newComment)
+ {
+ String oldComment = comment;
+ comment = newComment;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.COMMENT__COMMENT, oldComment, comment));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.COMMENT__COMMENT:
+ return getComment();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.COMMENT__COMMENT:
+ setComment((String)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.COMMENT__COMMENT:
+ setComment(COMMENT_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.COMMENT__COMMENT:
+ return COMMENT_EDEFAULT == null ? comment != null : !COMMENT_EDEFAULT.equals(comment);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (comment: ");
+ result.append(comment);
+ result.append(')');
+ return result.toString();
+ }
+
+} //CommentImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/CondBlockImpl.java b/csep/src-gen/csep/coffeeScript/impl/CondBlockImpl.java
new file mode 100644
index 0000000..a61abde
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/CondBlockImpl.java
@@ -0,0 +1,337 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Block;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.CondBlock;
+import csep.coffeeScript.Expression;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Cond Block
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.CondBlockImpl#getOperator Operator }
+ * {@link csep.coffeeScript.impl.CondBlockImpl#getCondition Condition }
+ * {@link csep.coffeeScript.impl.CondBlockImpl#getAction Action }
+ *
+ *
+ *
+ * @generated
+ */
+public class CondBlockImpl extends MinimalEObjectImpl.Container implements CondBlock
+{
+ /**
+ * The default value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected static final String OPERATOR_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected String operator = OPERATOR_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getCondition() Condition }' containment reference.
+ *
+ *
+ * @see #getCondition()
+ * @generated
+ * @ordered
+ */
+ protected Expression condition;
+
+ /**
+ * The cached value of the '{@link #getAction() Action }' containment reference.
+ *
+ *
+ * @see #getAction()
+ * @generated
+ * @ordered
+ */
+ protected Block action;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected CondBlockImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.COND_BLOCK;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getOperator()
+ {
+ return operator;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setOperator(String newOperator)
+ {
+ String oldOperator = operator;
+ operator = newOperator;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.COND_BLOCK__OPERATOR, oldOperator, operator));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getCondition()
+ {
+ return condition;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetCondition(Expression newCondition, NotificationChain msgs)
+ {
+ Expression oldCondition = condition;
+ condition = newCondition;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.COND_BLOCK__CONDITION, oldCondition, newCondition);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setCondition(Expression newCondition)
+ {
+ if (newCondition != condition)
+ {
+ NotificationChain msgs = null;
+ if (condition != null)
+ msgs = ((InternalEObject)condition).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.COND_BLOCK__CONDITION, null, msgs);
+ if (newCondition != null)
+ msgs = ((InternalEObject)newCondition).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.COND_BLOCK__CONDITION, null, msgs);
+ msgs = basicSetCondition(newCondition, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.COND_BLOCK__CONDITION, newCondition, newCondition));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block getAction()
+ {
+ return action;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetAction(Block newAction, NotificationChain msgs)
+ {
+ Block oldAction = action;
+ action = newAction;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.COND_BLOCK__ACTION, oldAction, newAction);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setAction(Block newAction)
+ {
+ if (newAction != action)
+ {
+ NotificationChain msgs = null;
+ if (action != null)
+ msgs = ((InternalEObject)action).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.COND_BLOCK__ACTION, null, msgs);
+ if (newAction != null)
+ msgs = ((InternalEObject)newAction).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.COND_BLOCK__ACTION, null, msgs);
+ msgs = basicSetAction(newAction, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.COND_BLOCK__ACTION, newAction, newAction));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.COND_BLOCK__CONDITION:
+ return basicSetCondition(null, msgs);
+ case CoffeeScriptPackage.COND_BLOCK__ACTION:
+ return basicSetAction(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.COND_BLOCK__OPERATOR:
+ return getOperator();
+ case CoffeeScriptPackage.COND_BLOCK__CONDITION:
+ return getCondition();
+ case CoffeeScriptPackage.COND_BLOCK__ACTION:
+ return getAction();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.COND_BLOCK__OPERATOR:
+ setOperator((String)newValue);
+ return;
+ case CoffeeScriptPackage.COND_BLOCK__CONDITION:
+ setCondition((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.COND_BLOCK__ACTION:
+ setAction((Block)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.COND_BLOCK__OPERATOR:
+ setOperator(OPERATOR_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.COND_BLOCK__CONDITION:
+ setCondition((Expression)null);
+ return;
+ case CoffeeScriptPackage.COND_BLOCK__ACTION:
+ setAction((Block)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.COND_BLOCK__OPERATOR:
+ return OPERATOR_EDEFAULT == null ? operator != null : !OPERATOR_EDEFAULT.equals(operator);
+ case CoffeeScriptPackage.COND_BLOCK__CONDITION:
+ return condition != null;
+ case CoffeeScriptPackage.COND_BLOCK__ACTION:
+ return action != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (operator: ");
+ result.append(operator);
+ result.append(')');
+ return result.toString();
+ }
+
+} //CondBlockImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/DictItemImpl.java b/csep/src-gen/csep/coffeeScript/impl/DictItemImpl.java
new file mode 100644
index 0000000..d5d966a
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/DictItemImpl.java
@@ -0,0 +1,266 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.DictItem;
+import csep.coffeeScript.DictKey;
+import csep.coffeeScript.Expression;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Dict Item
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.DictItemImpl#getKey Key }
+ * {@link csep.coffeeScript.impl.DictItemImpl#getValue Value }
+ *
+ *
+ *
+ * @generated
+ */
+public class DictItemImpl extends MinimalEObjectImpl.Container implements DictItem
+{
+ /**
+ * The cached value of the '{@link #getKey() Key }' containment reference.
+ *
+ *
+ * @see #getKey()
+ * @generated
+ * @ordered
+ */
+ protected DictKey key;
+
+ /**
+ * The cached value of the '{@link #getValue() Value }' containment reference.
+ *
+ *
+ * @see #getValue()
+ * @generated
+ * @ordered
+ */
+ protected Expression value;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected DictItemImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.DICT_ITEM;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public DictKey getKey()
+ {
+ return key;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetKey(DictKey newKey, NotificationChain msgs)
+ {
+ DictKey oldKey = key;
+ key = newKey;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICT_ITEM__KEY, oldKey, newKey);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setKey(DictKey newKey)
+ {
+ if (newKey != key)
+ {
+ NotificationChain msgs = null;
+ if (key != null)
+ msgs = ((InternalEObject)key).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICT_ITEM__KEY, null, msgs);
+ if (newKey != null)
+ msgs = ((InternalEObject)newKey).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICT_ITEM__KEY, null, msgs);
+ msgs = basicSetKey(newKey, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICT_ITEM__KEY, newKey, newKey));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getValue()
+ {
+ return value;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetValue(Expression newValue, NotificationChain msgs)
+ {
+ Expression oldValue = value;
+ value = newValue;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICT_ITEM__VALUE, oldValue, newValue);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setValue(Expression newValue)
+ {
+ if (newValue != value)
+ {
+ NotificationChain msgs = null;
+ if (value != null)
+ msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICT_ITEM__VALUE, null, msgs);
+ if (newValue != null)
+ msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICT_ITEM__VALUE, null, msgs);
+ msgs = basicSetValue(newValue, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICT_ITEM__VALUE, newValue, newValue));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEM__KEY:
+ return basicSetKey(null, msgs);
+ case CoffeeScriptPackage.DICT_ITEM__VALUE:
+ return basicSetValue(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEM__KEY:
+ return getKey();
+ case CoffeeScriptPackage.DICT_ITEM__VALUE:
+ return getValue();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEM__KEY:
+ setKey((DictKey)newValue);
+ return;
+ case CoffeeScriptPackage.DICT_ITEM__VALUE:
+ setValue((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEM__KEY:
+ setKey((DictKey)null);
+ return;
+ case CoffeeScriptPackage.DICT_ITEM__VALUE:
+ setValue((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEM__KEY:
+ return key != null;
+ case CoffeeScriptPackage.DICT_ITEM__VALUE:
+ return value != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //DictItemImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/DictItemsImpl.java b/csep/src-gen/csep/coffeeScript/impl/DictItemsImpl.java
new file mode 100644
index 0000000..782c6d7
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/DictItemsImpl.java
@@ -0,0 +1,193 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.DictItems;
+import csep.coffeeScript.ExplicitDictItems;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Dict Items
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.DictItemsImpl#getDummy Dummy }
+ *
+ *
+ *
+ * @generated
+ */
+public class DictItemsImpl extends DictionaryImpl implements DictItems
+{
+ /**
+ * The cached value of the '{@link #getDummy() Dummy }' containment reference.
+ *
+ *
+ * @see #getDummy()
+ * @generated
+ * @ordered
+ */
+ protected ExplicitDictItems dummy;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected DictItemsImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.DICT_ITEMS;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ExplicitDictItems getDummy()
+ {
+ return dummy;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDummy(ExplicitDictItems newDummy, NotificationChain msgs)
+ {
+ ExplicitDictItems oldDummy = dummy;
+ dummy = newDummy;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICT_ITEMS__DUMMY, oldDummy, newDummy);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDummy(ExplicitDictItems newDummy)
+ {
+ if (newDummy != dummy)
+ {
+ NotificationChain msgs = null;
+ if (dummy != null)
+ msgs = ((InternalEObject)dummy).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICT_ITEMS__DUMMY, null, msgs);
+ if (newDummy != null)
+ msgs = ((InternalEObject)newDummy).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICT_ITEMS__DUMMY, null, msgs);
+ msgs = basicSetDummy(newDummy, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICT_ITEMS__DUMMY, newDummy, newDummy));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEMS__DUMMY:
+ return basicSetDummy(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEMS__DUMMY:
+ return getDummy();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEMS__DUMMY:
+ setDummy((ExplicitDictItems)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEMS__DUMMY:
+ setDummy((ExplicitDictItems)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_ITEMS__DUMMY:
+ return dummy != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //DictItemsImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/DictKeyImpl.java b/csep/src-gen/csep/coffeeScript/impl/DictKeyImpl.java
new file mode 100644
index 0000000..16aeca2
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/DictKeyImpl.java
@@ -0,0 +1,44 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.DictKey;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Dict Key
+ *
+ *
+ * @generated
+ */
+public class DictKeyImpl extends MinimalEObjectImpl.Container implements DictKey
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected DictKeyImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.DICT_KEY;
+ }
+
+} //DictKeyImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/DictLineImpl.java b/csep/src-gen/csep/coffeeScript/impl/DictLineImpl.java
new file mode 100644
index 0000000..697c5bf
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/DictLineImpl.java
@@ -0,0 +1,240 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.DictItem;
+import csep.coffeeScript.DictLine;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Dict Line
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.DictLineImpl#getHead Head }
+ * {@link csep.coffeeScript.impl.DictLineImpl#getTail Tail }
+ *
+ *
+ *
+ * @generated
+ */
+public class DictLineImpl extends MinimalEObjectImpl.Container implements DictLine
+{
+ /**
+ * The cached value of the '{@link #getHead() Head }' containment reference.
+ *
+ *
+ * @see #getHead()
+ * @generated
+ * @ordered
+ */
+ protected DictItem head;
+
+ /**
+ * The cached value of the '{@link #getTail() Tail }' containment reference list.
+ *
+ *
+ * @see #getTail()
+ * @generated
+ * @ordered
+ */
+ protected EList tail;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected DictLineImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.DICT_LINE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public DictItem getHead()
+ {
+ return head;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetHead(DictItem newHead, NotificationChain msgs)
+ {
+ DictItem oldHead = head;
+ head = newHead;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICT_LINE__HEAD, oldHead, newHead);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setHead(DictItem newHead)
+ {
+ if (newHead != head)
+ {
+ NotificationChain msgs = null;
+ if (head != null)
+ msgs = ((InternalEObject)head).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICT_LINE__HEAD, null, msgs);
+ if (newHead != null)
+ msgs = ((InternalEObject)newHead).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICT_LINE__HEAD, null, msgs);
+ msgs = basicSetHead(newHead, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICT_LINE__HEAD, newHead, newHead));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getTail()
+ {
+ if (tail == null)
+ {
+ tail = new EObjectContainmentEList(DictItem.class, this, CoffeeScriptPackage.DICT_LINE__TAIL);
+ }
+ return tail;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_LINE__HEAD:
+ return basicSetHead(null, msgs);
+ case CoffeeScriptPackage.DICT_LINE__TAIL:
+ return ((InternalEList)getTail()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_LINE__HEAD:
+ return getHead();
+ case CoffeeScriptPackage.DICT_LINE__TAIL:
+ return getTail();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_LINE__HEAD:
+ setHead((DictItem)newValue);
+ return;
+ case CoffeeScriptPackage.DICT_LINE__TAIL:
+ getTail().clear();
+ getTail().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_LINE__HEAD:
+ setHead((DictItem)null);
+ return;
+ case CoffeeScriptPackage.DICT_LINE__TAIL:
+ getTail().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICT_LINE__HEAD:
+ return head != null;
+ case CoffeeScriptPackage.DICT_LINE__TAIL:
+ return tail != null && !tail.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //DictLineImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/DictionaryImpl.java b/csep/src-gen/csep/coffeeScript/impl/DictionaryImpl.java
new file mode 100644
index 0000000..43cba77
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/DictionaryImpl.java
@@ -0,0 +1,264 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Dictionary;
+import csep.coffeeScript.Expression;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Dictionary
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.DictionaryImpl#isSplat Splat }
+ * {@link csep.coffeeScript.impl.DictionaryImpl#getDefaultValue Default Value }
+ *
+ *
+ *
+ * @generated
+ */
+public class DictionaryImpl extends PrimaryExpressionImpl implements Dictionary
+{
+ /**
+ * The default value of the '{@link #isSplat() Splat }' attribute.
+ *
+ *
+ * @see #isSplat()
+ * @generated
+ * @ordered
+ */
+ protected static final boolean SPLAT_EDEFAULT = false;
+
+ /**
+ * The cached value of the '{@link #isSplat() Splat }' attribute.
+ *
+ *
+ * @see #isSplat()
+ * @generated
+ * @ordered
+ */
+ protected boolean splat = SPLAT_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getDefaultValue() Default Value }' containment reference.
+ *
+ *
+ * @see #getDefaultValue()
+ * @generated
+ * @ordered
+ */
+ protected Expression defaultValue;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected DictionaryImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.DICTIONARY;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public boolean isSplat()
+ {
+ return splat;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSplat(boolean newSplat)
+ {
+ boolean oldSplat = splat;
+ splat = newSplat;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICTIONARY__SPLAT, oldSplat, splat));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getDefaultValue()
+ {
+ return defaultValue;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDefaultValue(Expression newDefaultValue, NotificationChain msgs)
+ {
+ Expression oldDefaultValue = defaultValue;
+ defaultValue = newDefaultValue;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICTIONARY__DEFAULT_VALUE, oldDefaultValue, newDefaultValue);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDefaultValue(Expression newDefaultValue)
+ {
+ if (newDefaultValue != defaultValue)
+ {
+ NotificationChain msgs = null;
+ if (defaultValue != null)
+ msgs = ((InternalEObject)defaultValue).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICTIONARY__DEFAULT_VALUE, null, msgs);
+ if (newDefaultValue != null)
+ msgs = ((InternalEObject)newDefaultValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.DICTIONARY__DEFAULT_VALUE, null, msgs);
+ msgs = basicSetDefaultValue(newDefaultValue, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.DICTIONARY__DEFAULT_VALUE, newDefaultValue, newDefaultValue));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICTIONARY__DEFAULT_VALUE:
+ return basicSetDefaultValue(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICTIONARY__SPLAT:
+ return isSplat();
+ case CoffeeScriptPackage.DICTIONARY__DEFAULT_VALUE:
+ return getDefaultValue();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICTIONARY__SPLAT:
+ setSplat((Boolean)newValue);
+ return;
+ case CoffeeScriptPackage.DICTIONARY__DEFAULT_VALUE:
+ setDefaultValue((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICTIONARY__SPLAT:
+ setSplat(SPLAT_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.DICTIONARY__DEFAULT_VALUE:
+ setDefaultValue((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.DICTIONARY__SPLAT:
+ return splat != SPLAT_EDEFAULT;
+ case CoffeeScriptPackage.DICTIONARY__DEFAULT_VALUE:
+ return defaultValue != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (splat: ");
+ result.append(splat);
+ result.append(')');
+ return result.toString();
+ }
+
+} //DictionaryImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ExplicitArgListImpl.java b/csep/src-gen/csep/coffeeScript/impl/ExplicitArgListImpl.java
new file mode 100644
index 0000000..4fb798f
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ExplicitArgListImpl.java
@@ -0,0 +1,167 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.ArgLine;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.ExplicitArgList;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Explicit Arg List
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.ExplicitArgListImpl#getLines Lines }
+ *
+ *
+ *
+ * @generated
+ */
+public class ExplicitArgListImpl extends MinimalEObjectImpl.Container implements ExplicitArgList
+{
+ /**
+ * The cached value of the '{@link #getLines() Lines }' containment reference list.
+ *
+ *
+ * @see #getLines()
+ * @generated
+ * @ordered
+ */
+ protected EList lines;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ExplicitArgListImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.EXPLICIT_ARG_LIST;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getLines()
+ {
+ if (lines == null)
+ {
+ lines = new EObjectContainmentEList(ArgLine.class, this, CoffeeScriptPackage.EXPLICIT_ARG_LIST__LINES);
+ }
+ return lines;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_ARG_LIST__LINES:
+ return ((InternalEList)getLines()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_ARG_LIST__LINES:
+ return getLines();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_ARG_LIST__LINES:
+ getLines().clear();
+ getLines().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_ARG_LIST__LINES:
+ getLines().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_ARG_LIST__LINES:
+ return lines != null && !lines.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //ExplicitArgListImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ExplicitDictItemsImpl.java b/csep/src-gen/csep/coffeeScript/impl/ExplicitDictItemsImpl.java
new file mode 100644
index 0000000..cdfa631
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ExplicitDictItemsImpl.java
@@ -0,0 +1,167 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.DictLine;
+import csep.coffeeScript.ExplicitDictItems;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Explicit Dict Items
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.ExplicitDictItemsImpl#getLines Lines }
+ *
+ *
+ *
+ * @generated
+ */
+public class ExplicitDictItemsImpl extends MinimalEObjectImpl.Container implements ExplicitDictItems
+{
+ /**
+ * The cached value of the '{@link #getLines() Lines }' containment reference list.
+ *
+ *
+ * @see #getLines()
+ * @generated
+ * @ordered
+ */
+ protected EList lines;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ExplicitDictItemsImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.EXPLICIT_DICT_ITEMS;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getLines()
+ {
+ if (lines == null)
+ {
+ lines = new EObjectContainmentEList(DictLine.class, this, CoffeeScriptPackage.EXPLICIT_DICT_ITEMS__LINES);
+ }
+ return lines;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_DICT_ITEMS__LINES:
+ return ((InternalEList)getLines()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_DICT_ITEMS__LINES:
+ return getLines();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_DICT_ITEMS__LINES:
+ getLines().clear();
+ getLines().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_DICT_ITEMS__LINES:
+ getLines().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPLICIT_DICT_ITEMS__LINES:
+ return lines != null && !lines.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //ExplicitDictItemsImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ExpressionImpl.java b/csep/src-gen/csep/coffeeScript/impl/ExpressionImpl.java
new file mode 100644
index 0000000..99e8be4
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ExpressionImpl.java
@@ -0,0 +1,454 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.ForSource;
+import csep.coffeeScript.ForValue;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Expression
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.ExpressionImpl#getIndexes Indexes }
+ * {@link csep.coffeeScript.impl.ExpressionImpl#getSource Source }
+ * {@link csep.coffeeScript.impl.ExpressionImpl#getLeft Left }
+ * {@link csep.coffeeScript.impl.ExpressionImpl#getOperator Operator }
+ * {@link csep.coffeeScript.impl.ExpressionImpl#getRight Right }
+ *
+ *
+ *
+ * @generated
+ */
+public class ExpressionImpl extends LineImpl implements Expression
+{
+ /**
+ * The cached value of the '{@link #getIndexes() Indexes }' containment reference list.
+ *
+ *
+ * @see #getIndexes()
+ * @generated
+ * @ordered
+ */
+ protected EList indexes;
+
+ /**
+ * The cached value of the '{@link #getSource() Source }' containment reference.
+ *
+ *
+ * @see #getSource()
+ * @generated
+ * @ordered
+ */
+ protected ForSource source;
+
+ /**
+ * The cached value of the '{@link #getLeft() Left }' containment reference.
+ *
+ *
+ * @see #getLeft()
+ * @generated
+ * @ordered
+ */
+ protected EObject left;
+
+ /**
+ * The default value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected static final String OPERATOR_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected String operator = OPERATOR_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getRight() Right }' containment reference.
+ *
+ *
+ * @see #getRight()
+ * @generated
+ * @ordered
+ */
+ protected Expression right;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ExpressionImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.EXPRESSION;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getIndexes()
+ {
+ if (indexes == null)
+ {
+ indexes = new EObjectContainmentEList(ForValue.class, this, CoffeeScriptPackage.EXPRESSION__INDEXES);
+ }
+ return indexes;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ForSource getSource()
+ {
+ return source;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetSource(ForSource newSource, NotificationChain msgs)
+ {
+ ForSource oldSource = source;
+ source = newSource;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.EXPRESSION__SOURCE, oldSource, newSource);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSource(ForSource newSource)
+ {
+ if (newSource != source)
+ {
+ NotificationChain msgs = null;
+ if (source != null)
+ msgs = ((InternalEObject)source).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.EXPRESSION__SOURCE, null, msgs);
+ if (newSource != null)
+ msgs = ((InternalEObject)newSource).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.EXPRESSION__SOURCE, null, msgs);
+ msgs = basicSetSource(newSource, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.EXPRESSION__SOURCE, newSource, newSource));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EObject getLeft()
+ {
+ return left;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetLeft(EObject newLeft, NotificationChain msgs)
+ {
+ EObject oldLeft = left;
+ left = newLeft;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.EXPRESSION__LEFT, oldLeft, newLeft);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLeft(EObject newLeft)
+ {
+ if (newLeft != left)
+ {
+ NotificationChain msgs = null;
+ if (left != null)
+ msgs = ((InternalEObject)left).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.EXPRESSION__LEFT, null, msgs);
+ if (newLeft != null)
+ msgs = ((InternalEObject)newLeft).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.EXPRESSION__LEFT, null, msgs);
+ msgs = basicSetLeft(newLeft, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.EXPRESSION__LEFT, newLeft, newLeft));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getOperator()
+ {
+ return operator;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setOperator(String newOperator)
+ {
+ String oldOperator = operator;
+ operator = newOperator;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.EXPRESSION__OPERATOR, oldOperator, operator));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getRight()
+ {
+ return right;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetRight(Expression newRight, NotificationChain msgs)
+ {
+ Expression oldRight = right;
+ right = newRight;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.EXPRESSION__RIGHT, oldRight, newRight);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRight(Expression newRight)
+ {
+ if (newRight != right)
+ {
+ NotificationChain msgs = null;
+ if (right != null)
+ msgs = ((InternalEObject)right).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.EXPRESSION__RIGHT, null, msgs);
+ if (newRight != null)
+ msgs = ((InternalEObject)newRight).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.EXPRESSION__RIGHT, null, msgs);
+ msgs = basicSetRight(newRight, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.EXPRESSION__RIGHT, newRight, newRight));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPRESSION__INDEXES:
+ return ((InternalEList)getIndexes()).basicRemove(otherEnd, msgs);
+ case CoffeeScriptPackage.EXPRESSION__SOURCE:
+ return basicSetSource(null, msgs);
+ case CoffeeScriptPackage.EXPRESSION__LEFT:
+ return basicSetLeft(null, msgs);
+ case CoffeeScriptPackage.EXPRESSION__RIGHT:
+ return basicSetRight(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPRESSION__INDEXES:
+ return getIndexes();
+ case CoffeeScriptPackage.EXPRESSION__SOURCE:
+ return getSource();
+ case CoffeeScriptPackage.EXPRESSION__LEFT:
+ return getLeft();
+ case CoffeeScriptPackage.EXPRESSION__OPERATOR:
+ return getOperator();
+ case CoffeeScriptPackage.EXPRESSION__RIGHT:
+ return getRight();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPRESSION__INDEXES:
+ getIndexes().clear();
+ getIndexes().addAll((Collection)newValue);
+ return;
+ case CoffeeScriptPackage.EXPRESSION__SOURCE:
+ setSource((ForSource)newValue);
+ return;
+ case CoffeeScriptPackage.EXPRESSION__LEFT:
+ setLeft((EObject)newValue);
+ return;
+ case CoffeeScriptPackage.EXPRESSION__OPERATOR:
+ setOperator((String)newValue);
+ return;
+ case CoffeeScriptPackage.EXPRESSION__RIGHT:
+ setRight((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPRESSION__INDEXES:
+ getIndexes().clear();
+ return;
+ case CoffeeScriptPackage.EXPRESSION__SOURCE:
+ setSource((ForSource)null);
+ return;
+ case CoffeeScriptPackage.EXPRESSION__LEFT:
+ setLeft((EObject)null);
+ return;
+ case CoffeeScriptPackage.EXPRESSION__OPERATOR:
+ setOperator(OPERATOR_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.EXPRESSION__RIGHT:
+ setRight((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.EXPRESSION__INDEXES:
+ return indexes != null && !indexes.isEmpty();
+ case CoffeeScriptPackage.EXPRESSION__SOURCE:
+ return source != null;
+ case CoffeeScriptPackage.EXPRESSION__LEFT:
+ return left != null;
+ case CoffeeScriptPackage.EXPRESSION__OPERATOR:
+ return OPERATOR_EDEFAULT == null ? operator != null : !OPERATOR_EDEFAULT.equals(operator);
+ case CoffeeScriptPackage.EXPRESSION__RIGHT:
+ return right != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (operator: ");
+ result.append(operator);
+ result.append(')');
+ return result.toString();
+ }
+
+} //ExpressionImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/FeatureCallImpl.java b/csep/src-gen/csep/coffeeScript/impl/FeatureCallImpl.java
new file mode 100644
index 0000000..ac4dfcf
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/FeatureCallImpl.java
@@ -0,0 +1,44 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.FeatureCall;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Feature Call
+ *
+ *
+ * @generated
+ */
+public class FeatureCallImpl extends MinimalEObjectImpl.Container implements FeatureCall
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected FeatureCallImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.FEATURE_CALL;
+ }
+
+} //FeatureCallImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ForImpl.java b/csep/src-gen/csep/coffeeScript/impl/ForImpl.java
new file mode 100644
index 0000000..8ea1ed1
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ForImpl.java
@@ -0,0 +1,336 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.For;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'For
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.ForImpl#getDummy Dummy }
+ * {@link csep.coffeeScript.impl.ForImpl#getBody Body }
+ * {@link csep.coffeeScript.impl.ForImpl#getLoop Loop }
+ *
+ *
+ *
+ * @generated
+ */
+public class ForImpl extends ExpressionImpl implements For
+{
+ /**
+ * The cached value of the '{@link #getDummy() Dummy }' containment reference.
+ *
+ *
+ * @see #getDummy()
+ * @generated
+ * @ordered
+ */
+ protected Expression dummy;
+
+ /**
+ * The cached value of the '{@link #getBody() Body }' containment reference.
+ *
+ *
+ * @see #getBody()
+ * @generated
+ * @ordered
+ */
+ protected EObject body;
+
+ /**
+ * The cached value of the '{@link #getLoop() Loop }' containment reference.
+ *
+ *
+ * @see #getLoop()
+ * @generated
+ * @ordered
+ */
+ protected Expression loop;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ForImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.FOR;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getDummy()
+ {
+ return dummy;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDummy(Expression newDummy, NotificationChain msgs)
+ {
+ Expression oldDummy = dummy;
+ dummy = newDummy;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR__DUMMY, oldDummy, newDummy);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDummy(Expression newDummy)
+ {
+ if (newDummy != dummy)
+ {
+ NotificationChain msgs = null;
+ if (dummy != null)
+ msgs = ((InternalEObject)dummy).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR__DUMMY, null, msgs);
+ if (newDummy != null)
+ msgs = ((InternalEObject)newDummy).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR__DUMMY, null, msgs);
+ msgs = basicSetDummy(newDummy, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR__DUMMY, newDummy, newDummy));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EObject getBody()
+ {
+ return body;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetBody(EObject newBody, NotificationChain msgs)
+ {
+ EObject oldBody = body;
+ body = newBody;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR__BODY, oldBody, newBody);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setBody(EObject newBody)
+ {
+ if (newBody != body)
+ {
+ NotificationChain msgs = null;
+ if (body != null)
+ msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR__BODY, null, msgs);
+ if (newBody != null)
+ msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR__BODY, null, msgs);
+ msgs = basicSetBody(newBody, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR__BODY, newBody, newBody));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getLoop()
+ {
+ return loop;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetLoop(Expression newLoop, NotificationChain msgs)
+ {
+ Expression oldLoop = loop;
+ loop = newLoop;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR__LOOP, oldLoop, newLoop);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLoop(Expression newLoop)
+ {
+ if (newLoop != loop)
+ {
+ NotificationChain msgs = null;
+ if (loop != null)
+ msgs = ((InternalEObject)loop).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR__LOOP, null, msgs);
+ if (newLoop != null)
+ msgs = ((InternalEObject)newLoop).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR__LOOP, null, msgs);
+ msgs = basicSetLoop(newLoop, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR__LOOP, newLoop, newLoop));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR__DUMMY:
+ return basicSetDummy(null, msgs);
+ case CoffeeScriptPackage.FOR__BODY:
+ return basicSetBody(null, msgs);
+ case CoffeeScriptPackage.FOR__LOOP:
+ return basicSetLoop(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR__DUMMY:
+ return getDummy();
+ case CoffeeScriptPackage.FOR__BODY:
+ return getBody();
+ case CoffeeScriptPackage.FOR__LOOP:
+ return getLoop();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR__DUMMY:
+ setDummy((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.FOR__BODY:
+ setBody((EObject)newValue);
+ return;
+ case CoffeeScriptPackage.FOR__LOOP:
+ setLoop((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR__DUMMY:
+ setDummy((Expression)null);
+ return;
+ case CoffeeScriptPackage.FOR__BODY:
+ setBody((EObject)null);
+ return;
+ case CoffeeScriptPackage.FOR__LOOP:
+ setLoop((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR__DUMMY:
+ return dummy != null;
+ case CoffeeScriptPackage.FOR__BODY:
+ return body != null;
+ case CoffeeScriptPackage.FOR__LOOP:
+ return loop != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //ForImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ForSourceImpl.java b/csep/src-gen/csep/coffeeScript/impl/ForSourceImpl.java
new file mode 100644
index 0000000..a368941
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ForSourceImpl.java
@@ -0,0 +1,336 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.ForSource;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'For Source
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.ForSourceImpl#getSource Source }
+ * {@link csep.coffeeScript.impl.ForSourceImpl#getWhen When }
+ * {@link csep.coffeeScript.impl.ForSourceImpl#getBy By }
+ *
+ *
+ *
+ * @generated
+ */
+public class ForSourceImpl extends MinimalEObjectImpl.Container implements ForSource
+{
+ /**
+ * The cached value of the '{@link #getSource() Source }' containment reference.
+ *
+ *
+ * @see #getSource()
+ * @generated
+ * @ordered
+ */
+ protected Expression source;
+
+ /**
+ * The cached value of the '{@link #getWhen() When }' containment reference.
+ *
+ *
+ * @see #getWhen()
+ * @generated
+ * @ordered
+ */
+ protected Expression when;
+
+ /**
+ * The cached value of the '{@link #getBy() By }' containment reference.
+ *
+ *
+ * @see #getBy()
+ * @generated
+ * @ordered
+ */
+ protected Expression by;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ForSourceImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.FOR_SOURCE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getSource()
+ {
+ return source;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetSource(Expression newSource, NotificationChain msgs)
+ {
+ Expression oldSource = source;
+ source = newSource;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR_SOURCE__SOURCE, oldSource, newSource);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSource(Expression newSource)
+ {
+ if (newSource != source)
+ {
+ NotificationChain msgs = null;
+ if (source != null)
+ msgs = ((InternalEObject)source).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR_SOURCE__SOURCE, null, msgs);
+ if (newSource != null)
+ msgs = ((InternalEObject)newSource).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR_SOURCE__SOURCE, null, msgs);
+ msgs = basicSetSource(newSource, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR_SOURCE__SOURCE, newSource, newSource));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getWhen()
+ {
+ return when;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetWhen(Expression newWhen, NotificationChain msgs)
+ {
+ Expression oldWhen = when;
+ when = newWhen;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR_SOURCE__WHEN, oldWhen, newWhen);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setWhen(Expression newWhen)
+ {
+ if (newWhen != when)
+ {
+ NotificationChain msgs = null;
+ if (when != null)
+ msgs = ((InternalEObject)when).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR_SOURCE__WHEN, null, msgs);
+ if (newWhen != null)
+ msgs = ((InternalEObject)newWhen).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR_SOURCE__WHEN, null, msgs);
+ msgs = basicSetWhen(newWhen, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR_SOURCE__WHEN, newWhen, newWhen));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getBy()
+ {
+ return by;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetBy(Expression newBy, NotificationChain msgs)
+ {
+ Expression oldBy = by;
+ by = newBy;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR_SOURCE__BY, oldBy, newBy);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setBy(Expression newBy)
+ {
+ if (newBy != by)
+ {
+ NotificationChain msgs = null;
+ if (by != null)
+ msgs = ((InternalEObject)by).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR_SOURCE__BY, null, msgs);
+ if (newBy != null)
+ msgs = ((InternalEObject)newBy).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FOR_SOURCE__BY, null, msgs);
+ msgs = basicSetBy(newBy, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FOR_SOURCE__BY, newBy, newBy));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR_SOURCE__SOURCE:
+ return basicSetSource(null, msgs);
+ case CoffeeScriptPackage.FOR_SOURCE__WHEN:
+ return basicSetWhen(null, msgs);
+ case CoffeeScriptPackage.FOR_SOURCE__BY:
+ return basicSetBy(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR_SOURCE__SOURCE:
+ return getSource();
+ case CoffeeScriptPackage.FOR_SOURCE__WHEN:
+ return getWhen();
+ case CoffeeScriptPackage.FOR_SOURCE__BY:
+ return getBy();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR_SOURCE__SOURCE:
+ setSource((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.FOR_SOURCE__WHEN:
+ setWhen((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.FOR_SOURCE__BY:
+ setBy((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR_SOURCE__SOURCE:
+ setSource((Expression)null);
+ return;
+ case CoffeeScriptPackage.FOR_SOURCE__WHEN:
+ setWhen((Expression)null);
+ return;
+ case CoffeeScriptPackage.FOR_SOURCE__BY:
+ setBy((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FOR_SOURCE__SOURCE:
+ return source != null;
+ case CoffeeScriptPackage.FOR_SOURCE__WHEN:
+ return when != null;
+ case CoffeeScriptPackage.FOR_SOURCE__BY:
+ return by != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //ForSourceImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ForValueImpl.java b/csep/src-gen/csep/coffeeScript/impl/ForValueImpl.java
new file mode 100644
index 0000000..754a854
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ForValueImpl.java
@@ -0,0 +1,44 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.ForValue;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'For Value
+ *
+ *
+ * @generated
+ */
+public class ForValueImpl extends MinimalEObjectImpl.Container implements ForValue
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ForValueImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.FOR_VALUE;
+ }
+
+} //ForValueImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/FunctionCallImpl.java b/csep/src-gen/csep/coffeeScript/impl/FunctionCallImpl.java
new file mode 100644
index 0000000..c65b144
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/FunctionCallImpl.java
@@ -0,0 +1,193 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.ArgList;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.FunctionCall;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Function Call
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.FunctionCallImpl#getArgs Args }
+ *
+ *
+ *
+ * @generated
+ */
+public class FunctionCallImpl extends FeatureCallImpl implements FunctionCall
+{
+ /**
+ * The cached value of the '{@link #getArgs() Args }' containment reference.
+ *
+ *
+ * @see #getArgs()
+ * @generated
+ * @ordered
+ */
+ protected ArgList args;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected FunctionCallImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.FUNCTION_CALL;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ArgList getArgs()
+ {
+ return args;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetArgs(ArgList newArgs, NotificationChain msgs)
+ {
+ ArgList oldArgs = args;
+ args = newArgs;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FUNCTION_CALL__ARGS, oldArgs, newArgs);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setArgs(ArgList newArgs)
+ {
+ if (newArgs != args)
+ {
+ NotificationChain msgs = null;
+ if (args != null)
+ msgs = ((InternalEObject)args).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FUNCTION_CALL__ARGS, null, msgs);
+ if (newArgs != null)
+ msgs = ((InternalEObject)newArgs).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.FUNCTION_CALL__ARGS, null, msgs);
+ msgs = basicSetArgs(newArgs, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.FUNCTION_CALL__ARGS, newArgs, newArgs));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FUNCTION_CALL__ARGS:
+ return basicSetArgs(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FUNCTION_CALL__ARGS:
+ return getArgs();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FUNCTION_CALL__ARGS:
+ setArgs((ArgList)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FUNCTION_CALL__ARGS:
+ setArgs((ArgList)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.FUNCTION_CALL__ARGS:
+ return args != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //FunctionCallImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/IdImpl.java b/csep/src-gen/csep/coffeeScript/impl/IdImpl.java
new file mode 100644
index 0000000..6f432e7
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/IdImpl.java
@@ -0,0 +1,831 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Assignable;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.DictKey;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.ForSource;
+import csep.coffeeScript.ForValue;
+import csep.coffeeScript.Id;
+import csep.coffeeScript.Line;
+import csep.coffeeScript.Param;
+import csep.coffeeScript.PrimaryExpression;
+import csep.coffeeScript.ThisProperty;
+import csep.coffeeScript.Variable;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Id
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.IdImpl#isSplat Splat }
+ * {@link csep.coffeeScript.impl.IdImpl#getDefaultValue Default Value }
+ * {@link csep.coffeeScript.impl.IdImpl#getIndexes Indexes }
+ * {@link csep.coffeeScript.impl.IdImpl#getSource Source }
+ * {@link csep.coffeeScript.impl.IdImpl#getLeft Left }
+ * {@link csep.coffeeScript.impl.IdImpl#getOperator Operator }
+ * {@link csep.coffeeScript.impl.IdImpl#getRight Right }
+ * {@link csep.coffeeScript.impl.IdImpl#getName Name }
+ * {@link csep.coffeeScript.impl.IdImpl#getProps Props }
+ *
+ *
+ *
+ * @generated
+ */
+public class IdImpl extends ForValueImpl implements Id
+{
+ /**
+ * The default value of the '{@link #isSplat() Splat }' attribute.
+ *
+ *
+ * @see #isSplat()
+ * @generated
+ * @ordered
+ */
+ protected static final boolean SPLAT_EDEFAULT = false;
+
+ /**
+ * The cached value of the '{@link #isSplat() Splat }' attribute.
+ *
+ *
+ * @see #isSplat()
+ * @generated
+ * @ordered
+ */
+ protected boolean splat = SPLAT_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getDefaultValue() Default Value }' containment reference.
+ *
+ *
+ * @see #getDefaultValue()
+ * @generated
+ * @ordered
+ */
+ protected Expression defaultValue;
+
+ /**
+ * The cached value of the '{@link #getIndexes() Indexes }' containment reference list.
+ *
+ *
+ * @see #getIndexes()
+ * @generated
+ * @ordered
+ */
+ protected EList indexes;
+
+ /**
+ * The cached value of the '{@link #getSource() Source }' containment reference.
+ *
+ *
+ * @see #getSource()
+ * @generated
+ * @ordered
+ */
+ protected ForSource source;
+
+ /**
+ * The cached value of the '{@link #getLeft() Left }' containment reference.
+ *
+ *
+ * @see #getLeft()
+ * @generated
+ * @ordered
+ */
+ protected EObject left;
+
+ /**
+ * The default value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected static final String OPERATOR_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected String operator = OPERATOR_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getRight() Right }' containment reference.
+ *
+ *
+ * @see #getRight()
+ * @generated
+ * @ordered
+ */
+ protected Expression right;
+
+ /**
+ * The default value of the '{@link #getName() Name }' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected static final String NAME_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getName() Name }' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected String name = NAME_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getProps() Props }' containment reference list.
+ *
+ *
+ * @see #getProps()
+ * @generated
+ * @ordered
+ */
+ protected EList props;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected IdImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.ID;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public boolean isSplat()
+ {
+ return splat;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSplat(boolean newSplat)
+ {
+ boolean oldSplat = splat;
+ splat = newSplat;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__SPLAT, oldSplat, splat));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getDefaultValue()
+ {
+ return defaultValue;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDefaultValue(Expression newDefaultValue, NotificationChain msgs)
+ {
+ Expression oldDefaultValue = defaultValue;
+ defaultValue = newDefaultValue;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__DEFAULT_VALUE, oldDefaultValue, newDefaultValue);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDefaultValue(Expression newDefaultValue)
+ {
+ if (newDefaultValue != defaultValue)
+ {
+ NotificationChain msgs = null;
+ if (defaultValue != null)
+ msgs = ((InternalEObject)defaultValue).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID__DEFAULT_VALUE, null, msgs);
+ if (newDefaultValue != null)
+ msgs = ((InternalEObject)newDefaultValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID__DEFAULT_VALUE, null, msgs);
+ msgs = basicSetDefaultValue(newDefaultValue, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__DEFAULT_VALUE, newDefaultValue, newDefaultValue));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getIndexes()
+ {
+ if (indexes == null)
+ {
+ indexes = new EObjectContainmentEList(ForValue.class, this, CoffeeScriptPackage.ID__INDEXES);
+ }
+ return indexes;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ForSource getSource()
+ {
+ return source;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetSource(ForSource newSource, NotificationChain msgs)
+ {
+ ForSource oldSource = source;
+ source = newSource;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__SOURCE, oldSource, newSource);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSource(ForSource newSource)
+ {
+ if (newSource != source)
+ {
+ NotificationChain msgs = null;
+ if (source != null)
+ msgs = ((InternalEObject)source).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID__SOURCE, null, msgs);
+ if (newSource != null)
+ msgs = ((InternalEObject)newSource).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID__SOURCE, null, msgs);
+ msgs = basicSetSource(newSource, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__SOURCE, newSource, newSource));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EObject getLeft()
+ {
+ return left;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetLeft(EObject newLeft, NotificationChain msgs)
+ {
+ EObject oldLeft = left;
+ left = newLeft;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__LEFT, oldLeft, newLeft);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLeft(EObject newLeft)
+ {
+ if (newLeft != left)
+ {
+ NotificationChain msgs = null;
+ if (left != null)
+ msgs = ((InternalEObject)left).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID__LEFT, null, msgs);
+ if (newLeft != null)
+ msgs = ((InternalEObject)newLeft).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID__LEFT, null, msgs);
+ msgs = basicSetLeft(newLeft, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__LEFT, newLeft, newLeft));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getOperator()
+ {
+ return operator;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setOperator(String newOperator)
+ {
+ String oldOperator = operator;
+ operator = newOperator;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__OPERATOR, oldOperator, operator));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getRight()
+ {
+ return right;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetRight(Expression newRight, NotificationChain msgs)
+ {
+ Expression oldRight = right;
+ right = newRight;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__RIGHT, oldRight, newRight);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRight(Expression newRight)
+ {
+ if (newRight != right)
+ {
+ NotificationChain msgs = null;
+ if (right != null)
+ msgs = ((InternalEObject)right).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID__RIGHT, null, msgs);
+ if (newRight != null)
+ msgs = ((InternalEObject)newRight).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID__RIGHT, null, msgs);
+ msgs = basicSetRight(newRight, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__RIGHT, newRight, newRight));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(String newName)
+ {
+ String oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID__NAME, oldName, name));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getProps()
+ {
+ if (props == null)
+ {
+ props = new EObjectContainmentEList(Id.class, this, CoffeeScriptPackage.ID__PROPS);
+ }
+ return props;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID__DEFAULT_VALUE:
+ return basicSetDefaultValue(null, msgs);
+ case CoffeeScriptPackage.ID__INDEXES:
+ return ((InternalEList)getIndexes()).basicRemove(otherEnd, msgs);
+ case CoffeeScriptPackage.ID__SOURCE:
+ return basicSetSource(null, msgs);
+ case CoffeeScriptPackage.ID__LEFT:
+ return basicSetLeft(null, msgs);
+ case CoffeeScriptPackage.ID__RIGHT:
+ return basicSetRight(null, msgs);
+ case CoffeeScriptPackage.ID__PROPS:
+ return ((InternalEList)getProps()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID__SPLAT:
+ return isSplat();
+ case CoffeeScriptPackage.ID__DEFAULT_VALUE:
+ return getDefaultValue();
+ case CoffeeScriptPackage.ID__INDEXES:
+ return getIndexes();
+ case CoffeeScriptPackage.ID__SOURCE:
+ return getSource();
+ case CoffeeScriptPackage.ID__LEFT:
+ return getLeft();
+ case CoffeeScriptPackage.ID__OPERATOR:
+ return getOperator();
+ case CoffeeScriptPackage.ID__RIGHT:
+ return getRight();
+ case CoffeeScriptPackage.ID__NAME:
+ return getName();
+ case CoffeeScriptPackage.ID__PROPS:
+ return getProps();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID__SPLAT:
+ setSplat((Boolean)newValue);
+ return;
+ case CoffeeScriptPackage.ID__DEFAULT_VALUE:
+ setDefaultValue((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.ID__INDEXES:
+ getIndexes().clear();
+ getIndexes().addAll((Collection)newValue);
+ return;
+ case CoffeeScriptPackage.ID__SOURCE:
+ setSource((ForSource)newValue);
+ return;
+ case CoffeeScriptPackage.ID__LEFT:
+ setLeft((EObject)newValue);
+ return;
+ case CoffeeScriptPackage.ID__OPERATOR:
+ setOperator((String)newValue);
+ return;
+ case CoffeeScriptPackage.ID__RIGHT:
+ setRight((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.ID__NAME:
+ setName((String)newValue);
+ return;
+ case CoffeeScriptPackage.ID__PROPS:
+ getProps().clear();
+ getProps().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID__SPLAT:
+ setSplat(SPLAT_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.ID__DEFAULT_VALUE:
+ setDefaultValue((Expression)null);
+ return;
+ case CoffeeScriptPackage.ID__INDEXES:
+ getIndexes().clear();
+ return;
+ case CoffeeScriptPackage.ID__SOURCE:
+ setSource((ForSource)null);
+ return;
+ case CoffeeScriptPackage.ID__LEFT:
+ setLeft((EObject)null);
+ return;
+ case CoffeeScriptPackage.ID__OPERATOR:
+ setOperator(OPERATOR_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.ID__RIGHT:
+ setRight((Expression)null);
+ return;
+ case CoffeeScriptPackage.ID__NAME:
+ setName(NAME_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.ID__PROPS:
+ getProps().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID__SPLAT:
+ return splat != SPLAT_EDEFAULT;
+ case CoffeeScriptPackage.ID__DEFAULT_VALUE:
+ return defaultValue != null;
+ case CoffeeScriptPackage.ID__INDEXES:
+ return indexes != null && !indexes.isEmpty();
+ case CoffeeScriptPackage.ID__SOURCE:
+ return source != null;
+ case CoffeeScriptPackage.ID__LEFT:
+ return left != null;
+ case CoffeeScriptPackage.ID__OPERATOR:
+ return OPERATOR_EDEFAULT == null ? operator != null : !OPERATOR_EDEFAULT.equals(operator);
+ case CoffeeScriptPackage.ID__RIGHT:
+ return right != null;
+ case CoffeeScriptPackage.ID__NAME:
+ return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+ case CoffeeScriptPackage.ID__PROPS:
+ return props != null && !props.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public int eBaseStructuralFeatureID(int derivedFeatureID, Class baseClass)
+ {
+ if (baseClass == PrimaryExpression.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Param.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == ThisProperty.class)
+ {
+ switch (derivedFeatureID)
+ {
+ case CoffeeScriptPackage.ID__SPLAT: return CoffeeScriptPackage.THIS_PROPERTY__SPLAT;
+ case CoffeeScriptPackage.ID__DEFAULT_VALUE: return CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE;
+ default: return -1;
+ }
+ }
+ if (baseClass == Line.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Expression.class)
+ {
+ switch (derivedFeatureID)
+ {
+ case CoffeeScriptPackage.ID__INDEXES: return CoffeeScriptPackage.EXPRESSION__INDEXES;
+ case CoffeeScriptPackage.ID__SOURCE: return CoffeeScriptPackage.EXPRESSION__SOURCE;
+ case CoffeeScriptPackage.ID__LEFT: return CoffeeScriptPackage.EXPRESSION__LEFT;
+ case CoffeeScriptPackage.ID__OPERATOR: return CoffeeScriptPackage.EXPRESSION__OPERATOR;
+ case CoffeeScriptPackage.ID__RIGHT: return CoffeeScriptPackage.EXPRESSION__RIGHT;
+ default: return -1;
+ }
+ }
+ if (baseClass == Assignable.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Variable.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == DictKey.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public int eDerivedStructuralFeatureID(int baseFeatureID, Class baseClass)
+ {
+ if (baseClass == PrimaryExpression.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Param.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == ThisProperty.class)
+ {
+ switch (baseFeatureID)
+ {
+ case CoffeeScriptPackage.THIS_PROPERTY__SPLAT: return CoffeeScriptPackage.ID__SPLAT;
+ case CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE: return CoffeeScriptPackage.ID__DEFAULT_VALUE;
+ default: return -1;
+ }
+ }
+ if (baseClass == Line.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Expression.class)
+ {
+ switch (baseFeatureID)
+ {
+ case CoffeeScriptPackage.EXPRESSION__INDEXES: return CoffeeScriptPackage.ID__INDEXES;
+ case CoffeeScriptPackage.EXPRESSION__SOURCE: return CoffeeScriptPackage.ID__SOURCE;
+ case CoffeeScriptPackage.EXPRESSION__LEFT: return CoffeeScriptPackage.ID__LEFT;
+ case CoffeeScriptPackage.EXPRESSION__OPERATOR: return CoffeeScriptPackage.ID__OPERATOR;
+ case CoffeeScriptPackage.EXPRESSION__RIGHT: return CoffeeScriptPackage.ID__RIGHT;
+ default: return -1;
+ }
+ }
+ if (baseClass == Assignable.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Variable.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == DictKey.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (splat: ");
+ result.append(splat);
+ result.append(", operator: ");
+ result.append(operator);
+ result.append(", name: ");
+ result.append(name);
+ result.append(')');
+ return result.toString();
+ }
+
+} //IdImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/IdRefImpl.java b/csep/src-gen/csep/coffeeScript/impl/IdRefImpl.java
new file mode 100644
index 0000000..6c1fede
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/IdRefImpl.java
@@ -0,0 +1,841 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Assignable;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.ForSource;
+import csep.coffeeScript.ForValue;
+import csep.coffeeScript.Id;
+import csep.coffeeScript.IdRef;
+import csep.coffeeScript.Index;
+import csep.coffeeScript.Line;
+import csep.coffeeScript.PrimaryExpression;
+import csep.coffeeScript.Property;
+import csep.coffeeScript.Variable;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Id Ref
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.IdRefImpl#getIndexes Indexes }
+ * {@link csep.coffeeScript.impl.IdRefImpl#getSource Source }
+ * {@link csep.coffeeScript.impl.IdRefImpl#getLeft Left }
+ * {@link csep.coffeeScript.impl.IdRefImpl#getOperator Operator }
+ * {@link csep.coffeeScript.impl.IdRefImpl#getRight Right }
+ * {@link csep.coffeeScript.impl.IdRefImpl#getVal Val }
+ * {@link csep.coffeeScript.impl.IdRefImpl#getAccessor Accessor }
+ * {@link csep.coffeeScript.impl.IdRefImpl#getProp Prop }
+ * {@link csep.coffeeScript.impl.IdRefImpl#getIndex Index }
+ *
+ *
+ *
+ * @generated
+ */
+public class IdRefImpl extends SuperClassImpl implements IdRef
+{
+ /**
+ * The cached value of the '{@link #getIndexes() Indexes }' containment reference list.
+ *
+ *
+ * @see #getIndexes()
+ * @generated
+ * @ordered
+ */
+ protected EList indexes;
+
+ /**
+ * The cached value of the '{@link #getSource() Source }' containment reference.
+ *
+ *
+ * @see #getSource()
+ * @generated
+ * @ordered
+ */
+ protected ForSource source;
+
+ /**
+ * The cached value of the '{@link #getLeft() Left }' containment reference.
+ *
+ *
+ * @see #getLeft()
+ * @generated
+ * @ordered
+ */
+ protected EObject left;
+
+ /**
+ * The default value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected static final String OPERATOR_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected String operator = OPERATOR_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getRight() Right }' containment reference.
+ *
+ *
+ * @see #getRight()
+ * @generated
+ * @ordered
+ */
+ protected Expression right;
+
+ /**
+ * The cached value of the '{@link #getVal() Val }' reference.
+ *
+ *
+ * @see #getVal()
+ * @generated
+ * @ordered
+ */
+ protected Id val;
+
+ /**
+ * The default value of the '{@link #getAccessor() Accessor }' attribute.
+ *
+ *
+ * @see #getAccessor()
+ * @generated
+ * @ordered
+ */
+ protected static final String ACCESSOR_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getAccessor() Accessor }' attribute.
+ *
+ *
+ * @see #getAccessor()
+ * @generated
+ * @ordered
+ */
+ protected String accessor = ACCESSOR_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getProp() Prop }' containment reference.
+ *
+ *
+ * @see #getProp()
+ * @generated
+ * @ordered
+ */
+ protected Id prop;
+
+ /**
+ * The cached value of the '{@link #getIndex() Index }' containment reference.
+ *
+ *
+ * @see #getIndex()
+ * @generated
+ * @ordered
+ */
+ protected Index index;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected IdRefImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.ID_REF;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getIndexes()
+ {
+ if (indexes == null)
+ {
+ indexes = new EObjectContainmentEList(ForValue.class, this, CoffeeScriptPackage.ID_REF__INDEXES);
+ }
+ return indexes;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ForSource getSource()
+ {
+ return source;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetSource(ForSource newSource, NotificationChain msgs)
+ {
+ ForSource oldSource = source;
+ source = newSource;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__SOURCE, oldSource, newSource);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSource(ForSource newSource)
+ {
+ if (newSource != source)
+ {
+ NotificationChain msgs = null;
+ if (source != null)
+ msgs = ((InternalEObject)source).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__SOURCE, null, msgs);
+ if (newSource != null)
+ msgs = ((InternalEObject)newSource).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__SOURCE, null, msgs);
+ msgs = basicSetSource(newSource, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__SOURCE, newSource, newSource));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EObject getLeft()
+ {
+ return left;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetLeft(EObject newLeft, NotificationChain msgs)
+ {
+ EObject oldLeft = left;
+ left = newLeft;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__LEFT, oldLeft, newLeft);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLeft(EObject newLeft)
+ {
+ if (newLeft != left)
+ {
+ NotificationChain msgs = null;
+ if (left != null)
+ msgs = ((InternalEObject)left).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__LEFT, null, msgs);
+ if (newLeft != null)
+ msgs = ((InternalEObject)newLeft).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__LEFT, null, msgs);
+ msgs = basicSetLeft(newLeft, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__LEFT, newLeft, newLeft));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getOperator()
+ {
+ return operator;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setOperator(String newOperator)
+ {
+ String oldOperator = operator;
+ operator = newOperator;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__OPERATOR, oldOperator, operator));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getRight()
+ {
+ return right;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetRight(Expression newRight, NotificationChain msgs)
+ {
+ Expression oldRight = right;
+ right = newRight;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__RIGHT, oldRight, newRight);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRight(Expression newRight)
+ {
+ if (newRight != right)
+ {
+ NotificationChain msgs = null;
+ if (right != null)
+ msgs = ((InternalEObject)right).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__RIGHT, null, msgs);
+ if (newRight != null)
+ msgs = ((InternalEObject)newRight).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__RIGHT, null, msgs);
+ msgs = basicSetRight(newRight, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__RIGHT, newRight, newRight));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Id getVal()
+ {
+ if (val != null && val.eIsProxy())
+ {
+ InternalEObject oldVal = (InternalEObject)val;
+ val = (Id)eResolveProxy(oldVal);
+ if (val != oldVal)
+ {
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.RESOLVE, CoffeeScriptPackage.ID_REF__VAL, oldVal, val));
+ }
+ }
+ return val;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Id basicGetVal()
+ {
+ return val;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setVal(Id newVal)
+ {
+ Id oldVal = val;
+ val = newVal;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__VAL, oldVal, val));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getAccessor()
+ {
+ return accessor;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setAccessor(String newAccessor)
+ {
+ String oldAccessor = accessor;
+ accessor = newAccessor;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__ACCESSOR, oldAccessor, accessor));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Id getProp()
+ {
+ return prop;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetProp(Id newProp, NotificationChain msgs)
+ {
+ Id oldProp = prop;
+ prop = newProp;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__PROP, oldProp, newProp);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setProp(Id newProp)
+ {
+ if (newProp != prop)
+ {
+ NotificationChain msgs = null;
+ if (prop != null)
+ msgs = ((InternalEObject)prop).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__PROP, null, msgs);
+ if (newProp != null)
+ msgs = ((InternalEObject)newProp).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__PROP, null, msgs);
+ msgs = basicSetProp(newProp, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__PROP, newProp, newProp));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Index getIndex()
+ {
+ return index;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetIndex(Index newIndex, NotificationChain msgs)
+ {
+ Index oldIndex = index;
+ index = newIndex;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__INDEX, oldIndex, newIndex);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setIndex(Index newIndex)
+ {
+ if (newIndex != index)
+ {
+ NotificationChain msgs = null;
+ if (index != null)
+ msgs = ((InternalEObject)index).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__INDEX, null, msgs);
+ if (newIndex != null)
+ msgs = ((InternalEObject)newIndex).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.ID_REF__INDEX, null, msgs);
+ msgs = basicSetIndex(newIndex, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.ID_REF__INDEX, newIndex, newIndex));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID_REF__INDEXES:
+ return ((InternalEList)getIndexes()).basicRemove(otherEnd, msgs);
+ case CoffeeScriptPackage.ID_REF__SOURCE:
+ return basicSetSource(null, msgs);
+ case CoffeeScriptPackage.ID_REF__LEFT:
+ return basicSetLeft(null, msgs);
+ case CoffeeScriptPackage.ID_REF__RIGHT:
+ return basicSetRight(null, msgs);
+ case CoffeeScriptPackage.ID_REF__PROP:
+ return basicSetProp(null, msgs);
+ case CoffeeScriptPackage.ID_REF__INDEX:
+ return basicSetIndex(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID_REF__INDEXES:
+ return getIndexes();
+ case CoffeeScriptPackage.ID_REF__SOURCE:
+ return getSource();
+ case CoffeeScriptPackage.ID_REF__LEFT:
+ return getLeft();
+ case CoffeeScriptPackage.ID_REF__OPERATOR:
+ return getOperator();
+ case CoffeeScriptPackage.ID_REF__RIGHT:
+ return getRight();
+ case CoffeeScriptPackage.ID_REF__VAL:
+ if (resolve) return getVal();
+ return basicGetVal();
+ case CoffeeScriptPackage.ID_REF__ACCESSOR:
+ return getAccessor();
+ case CoffeeScriptPackage.ID_REF__PROP:
+ return getProp();
+ case CoffeeScriptPackage.ID_REF__INDEX:
+ return getIndex();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID_REF__INDEXES:
+ getIndexes().clear();
+ getIndexes().addAll((Collection)newValue);
+ return;
+ case CoffeeScriptPackage.ID_REF__SOURCE:
+ setSource((ForSource)newValue);
+ return;
+ case CoffeeScriptPackage.ID_REF__LEFT:
+ setLeft((EObject)newValue);
+ return;
+ case CoffeeScriptPackage.ID_REF__OPERATOR:
+ setOperator((String)newValue);
+ return;
+ case CoffeeScriptPackage.ID_REF__RIGHT:
+ setRight((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.ID_REF__VAL:
+ setVal((Id)newValue);
+ return;
+ case CoffeeScriptPackage.ID_REF__ACCESSOR:
+ setAccessor((String)newValue);
+ return;
+ case CoffeeScriptPackage.ID_REF__PROP:
+ setProp((Id)newValue);
+ return;
+ case CoffeeScriptPackage.ID_REF__INDEX:
+ setIndex((Index)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID_REF__INDEXES:
+ getIndexes().clear();
+ return;
+ case CoffeeScriptPackage.ID_REF__SOURCE:
+ setSource((ForSource)null);
+ return;
+ case CoffeeScriptPackage.ID_REF__LEFT:
+ setLeft((EObject)null);
+ return;
+ case CoffeeScriptPackage.ID_REF__OPERATOR:
+ setOperator(OPERATOR_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.ID_REF__RIGHT:
+ setRight((Expression)null);
+ return;
+ case CoffeeScriptPackage.ID_REF__VAL:
+ setVal((Id)null);
+ return;
+ case CoffeeScriptPackage.ID_REF__ACCESSOR:
+ setAccessor(ACCESSOR_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.ID_REF__PROP:
+ setProp((Id)null);
+ return;
+ case CoffeeScriptPackage.ID_REF__INDEX:
+ setIndex((Index)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.ID_REF__INDEXES:
+ return indexes != null && !indexes.isEmpty();
+ case CoffeeScriptPackage.ID_REF__SOURCE:
+ return source != null;
+ case CoffeeScriptPackage.ID_REF__LEFT:
+ return left != null;
+ case CoffeeScriptPackage.ID_REF__OPERATOR:
+ return OPERATOR_EDEFAULT == null ? operator != null : !OPERATOR_EDEFAULT.equals(operator);
+ case CoffeeScriptPackage.ID_REF__RIGHT:
+ return right != null;
+ case CoffeeScriptPackage.ID_REF__VAL:
+ return val != null;
+ case CoffeeScriptPackage.ID_REF__ACCESSOR:
+ return ACCESSOR_EDEFAULT == null ? accessor != null : !ACCESSOR_EDEFAULT.equals(accessor);
+ case CoffeeScriptPackage.ID_REF__PROP:
+ return prop != null;
+ case CoffeeScriptPackage.ID_REF__INDEX:
+ return index != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public int eBaseStructuralFeatureID(int derivedFeatureID, Class baseClass)
+ {
+ if (baseClass == PrimaryExpression.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Line.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Expression.class)
+ {
+ switch (derivedFeatureID)
+ {
+ case CoffeeScriptPackage.ID_REF__INDEXES: return CoffeeScriptPackage.EXPRESSION__INDEXES;
+ case CoffeeScriptPackage.ID_REF__SOURCE: return CoffeeScriptPackage.EXPRESSION__SOURCE;
+ case CoffeeScriptPackage.ID_REF__LEFT: return CoffeeScriptPackage.EXPRESSION__LEFT;
+ case CoffeeScriptPackage.ID_REF__OPERATOR: return CoffeeScriptPackage.EXPRESSION__OPERATOR;
+ case CoffeeScriptPackage.ID_REF__RIGHT: return CoffeeScriptPackage.EXPRESSION__RIGHT;
+ default: return -1;
+ }
+ }
+ if (baseClass == Assignable.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Variable.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Property.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public int eDerivedStructuralFeatureID(int baseFeatureID, Class baseClass)
+ {
+ if (baseClass == PrimaryExpression.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Line.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Expression.class)
+ {
+ switch (baseFeatureID)
+ {
+ case CoffeeScriptPackage.EXPRESSION__INDEXES: return CoffeeScriptPackage.ID_REF__INDEXES;
+ case CoffeeScriptPackage.EXPRESSION__SOURCE: return CoffeeScriptPackage.ID_REF__SOURCE;
+ case CoffeeScriptPackage.EXPRESSION__LEFT: return CoffeeScriptPackage.ID_REF__LEFT;
+ case CoffeeScriptPackage.EXPRESSION__OPERATOR: return CoffeeScriptPackage.ID_REF__OPERATOR;
+ case CoffeeScriptPackage.EXPRESSION__RIGHT: return CoffeeScriptPackage.ID_REF__RIGHT;
+ default: return -1;
+ }
+ }
+ if (baseClass == Assignable.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Variable.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Property.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (operator: ");
+ result.append(operator);
+ result.append(", accessor: ");
+ result.append(accessor);
+ result.append(')');
+ return result.toString();
+ }
+
+} //IdRefImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/IfExpImpl.java b/csep/src-gen/csep/coffeeScript/impl/IfExpImpl.java
new file mode 100644
index 0000000..e5db384
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/IfExpImpl.java
@@ -0,0 +1,240 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Block;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.CondBlock;
+import csep.coffeeScript.IfExp;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'If Exp
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.IfExpImpl#getBlocks Blocks }
+ * {@link csep.coffeeScript.impl.IfExpImpl#getDefaultBlock Default Block }
+ *
+ *
+ *
+ * @generated
+ */
+public class IfExpImpl extends PrimaryExpressionImpl implements IfExp
+{
+ /**
+ * The cached value of the '{@link #getBlocks() Blocks }' containment reference list.
+ *
+ *
+ * @see #getBlocks()
+ * @generated
+ * @ordered
+ */
+ protected EList blocks;
+
+ /**
+ * The cached value of the '{@link #getDefaultBlock() Default Block }' containment reference.
+ *
+ *
+ * @see #getDefaultBlock()
+ * @generated
+ * @ordered
+ */
+ protected Block defaultBlock;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected IfExpImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.IF_EXP;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getBlocks()
+ {
+ if (blocks == null)
+ {
+ blocks = new EObjectContainmentEList(CondBlock.class, this, CoffeeScriptPackage.IF_EXP__BLOCKS);
+ }
+ return blocks;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block getDefaultBlock()
+ {
+ return defaultBlock;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDefaultBlock(Block newDefaultBlock, NotificationChain msgs)
+ {
+ Block oldDefaultBlock = defaultBlock;
+ defaultBlock = newDefaultBlock;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.IF_EXP__DEFAULT_BLOCK, oldDefaultBlock, newDefaultBlock);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDefaultBlock(Block newDefaultBlock)
+ {
+ if (newDefaultBlock != defaultBlock)
+ {
+ NotificationChain msgs = null;
+ if (defaultBlock != null)
+ msgs = ((InternalEObject)defaultBlock).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.IF_EXP__DEFAULT_BLOCK, null, msgs);
+ if (newDefaultBlock != null)
+ msgs = ((InternalEObject)newDefaultBlock).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.IF_EXP__DEFAULT_BLOCK, null, msgs);
+ msgs = basicSetDefaultBlock(newDefaultBlock, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.IF_EXP__DEFAULT_BLOCK, newDefaultBlock, newDefaultBlock));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF_EXP__BLOCKS:
+ return ((InternalEList)getBlocks()).basicRemove(otherEnd, msgs);
+ case CoffeeScriptPackage.IF_EXP__DEFAULT_BLOCK:
+ return basicSetDefaultBlock(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF_EXP__BLOCKS:
+ return getBlocks();
+ case CoffeeScriptPackage.IF_EXP__DEFAULT_BLOCK:
+ return getDefaultBlock();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF_EXP__BLOCKS:
+ getBlocks().clear();
+ getBlocks().addAll((Collection)newValue);
+ return;
+ case CoffeeScriptPackage.IF_EXP__DEFAULT_BLOCK:
+ setDefaultBlock((Block)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF_EXP__BLOCKS:
+ getBlocks().clear();
+ return;
+ case CoffeeScriptPackage.IF_EXP__DEFAULT_BLOCK:
+ setDefaultBlock((Block)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF_EXP__BLOCKS:
+ return blocks != null && !blocks.isEmpty();
+ case CoffeeScriptPackage.IF_EXP__DEFAULT_BLOCK:
+ return defaultBlock != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //IfExpImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/IfImpl.java b/csep/src-gen/csep/coffeeScript/impl/IfImpl.java
new file mode 100644
index 0000000..f501a03
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/IfImpl.java
@@ -0,0 +1,264 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.If;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'If
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.IfImpl#getDummy Dummy }
+ * {@link csep.coffeeScript.impl.IfImpl#getCondition Condition }
+ *
+ *
+ *
+ * @generated
+ */
+public class IfImpl extends ExpressionImpl implements If
+{
+ /**
+ * The cached value of the '{@link #getDummy() Dummy }' containment reference.
+ *
+ *
+ * @see #getDummy()
+ * @generated
+ * @ordered
+ */
+ protected Expression dummy;
+
+ /**
+ * The cached value of the '{@link #getCondition() Condition }' containment reference.
+ *
+ *
+ * @see #getCondition()
+ * @generated
+ * @ordered
+ */
+ protected Expression condition;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected IfImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.IF;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getDummy()
+ {
+ return dummy;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDummy(Expression newDummy, NotificationChain msgs)
+ {
+ Expression oldDummy = dummy;
+ dummy = newDummy;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.IF__DUMMY, oldDummy, newDummy);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDummy(Expression newDummy)
+ {
+ if (newDummy != dummy)
+ {
+ NotificationChain msgs = null;
+ if (dummy != null)
+ msgs = ((InternalEObject)dummy).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.IF__DUMMY, null, msgs);
+ if (newDummy != null)
+ msgs = ((InternalEObject)newDummy).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.IF__DUMMY, null, msgs);
+ msgs = basicSetDummy(newDummy, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.IF__DUMMY, newDummy, newDummy));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getCondition()
+ {
+ return condition;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetCondition(Expression newCondition, NotificationChain msgs)
+ {
+ Expression oldCondition = condition;
+ condition = newCondition;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.IF__CONDITION, oldCondition, newCondition);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setCondition(Expression newCondition)
+ {
+ if (newCondition != condition)
+ {
+ NotificationChain msgs = null;
+ if (condition != null)
+ msgs = ((InternalEObject)condition).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.IF__CONDITION, null, msgs);
+ if (newCondition != null)
+ msgs = ((InternalEObject)newCondition).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.IF__CONDITION, null, msgs);
+ msgs = basicSetCondition(newCondition, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.IF__CONDITION, newCondition, newCondition));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF__DUMMY:
+ return basicSetDummy(null, msgs);
+ case CoffeeScriptPackage.IF__CONDITION:
+ return basicSetCondition(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF__DUMMY:
+ return getDummy();
+ case CoffeeScriptPackage.IF__CONDITION:
+ return getCondition();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF__DUMMY:
+ setDummy((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.IF__CONDITION:
+ setCondition((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF__DUMMY:
+ setDummy((Expression)null);
+ return;
+ case CoffeeScriptPackage.IF__CONDITION:
+ setCondition((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.IF__DUMMY:
+ return dummy != null;
+ case CoffeeScriptPackage.IF__CONDITION:
+ return condition != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //IfImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/IndexImpl.java b/csep/src-gen/csep/coffeeScript/impl/IndexImpl.java
new file mode 100644
index 0000000..7a0128f
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/IndexImpl.java
@@ -0,0 +1,407 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.Index;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Index
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.IndexImpl#getDots Dots }
+ * {@link csep.coffeeScript.impl.IndexImpl#getEnd End }
+ * {@link csep.coffeeScript.impl.IndexImpl#getStart Start }
+ * {@link csep.coffeeScript.impl.IndexImpl#getExp Exp }
+ *
+ *
+ *
+ * @generated
+ */
+public class IndexImpl extends MinimalEObjectImpl.Container implements Index
+{
+ /**
+ * The default value of the '{@link #getDots() Dots }' attribute.
+ *
+ *
+ * @see #getDots()
+ * @generated
+ * @ordered
+ */
+ protected static final String DOTS_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getDots() Dots }' attribute.
+ *
+ *
+ * @see #getDots()
+ * @generated
+ * @ordered
+ */
+ protected String dots = DOTS_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getEnd() End }' containment reference.
+ *
+ *
+ * @see #getEnd()
+ * @generated
+ * @ordered
+ */
+ protected Expression end;
+
+ /**
+ * The cached value of the '{@link #getStart() Start }' containment reference.
+ *
+ *
+ * @see #getStart()
+ * @generated
+ * @ordered
+ */
+ protected Expression start;
+
+ /**
+ * The cached value of the '{@link #getExp() Exp }' containment reference.
+ *
+ *
+ * @see #getExp()
+ * @generated
+ * @ordered
+ */
+ protected Expression exp;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected IndexImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.INDEX;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getDots()
+ {
+ return dots;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDots(String newDots)
+ {
+ String oldDots = dots;
+ dots = newDots;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.INDEX__DOTS, oldDots, dots));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getEnd()
+ {
+ return end;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetEnd(Expression newEnd, NotificationChain msgs)
+ {
+ Expression oldEnd = end;
+ end = newEnd;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.INDEX__END, oldEnd, newEnd);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setEnd(Expression newEnd)
+ {
+ if (newEnd != end)
+ {
+ NotificationChain msgs = null;
+ if (end != null)
+ msgs = ((InternalEObject)end).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.INDEX__END, null, msgs);
+ if (newEnd != null)
+ msgs = ((InternalEObject)newEnd).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.INDEX__END, null, msgs);
+ msgs = basicSetEnd(newEnd, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.INDEX__END, newEnd, newEnd));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getStart()
+ {
+ return start;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetStart(Expression newStart, NotificationChain msgs)
+ {
+ Expression oldStart = start;
+ start = newStart;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.INDEX__START, oldStart, newStart);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setStart(Expression newStart)
+ {
+ if (newStart != start)
+ {
+ NotificationChain msgs = null;
+ if (start != null)
+ msgs = ((InternalEObject)start).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.INDEX__START, null, msgs);
+ if (newStart != null)
+ msgs = ((InternalEObject)newStart).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.INDEX__START, null, msgs);
+ msgs = basicSetStart(newStart, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.INDEX__START, newStart, newStart));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getExp()
+ {
+ return exp;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetExp(Expression newExp, NotificationChain msgs)
+ {
+ Expression oldExp = exp;
+ exp = newExp;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.INDEX__EXP, oldExp, newExp);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setExp(Expression newExp)
+ {
+ if (newExp != exp)
+ {
+ NotificationChain msgs = null;
+ if (exp != null)
+ msgs = ((InternalEObject)exp).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.INDEX__EXP, null, msgs);
+ if (newExp != null)
+ msgs = ((InternalEObject)newExp).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.INDEX__EXP, null, msgs);
+ msgs = basicSetExp(newExp, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.INDEX__EXP, newExp, newExp));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEX__END:
+ return basicSetEnd(null, msgs);
+ case CoffeeScriptPackage.INDEX__START:
+ return basicSetStart(null, msgs);
+ case CoffeeScriptPackage.INDEX__EXP:
+ return basicSetExp(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEX__DOTS:
+ return getDots();
+ case CoffeeScriptPackage.INDEX__END:
+ return getEnd();
+ case CoffeeScriptPackage.INDEX__START:
+ return getStart();
+ case CoffeeScriptPackage.INDEX__EXP:
+ return getExp();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEX__DOTS:
+ setDots((String)newValue);
+ return;
+ case CoffeeScriptPackage.INDEX__END:
+ setEnd((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.INDEX__START:
+ setStart((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.INDEX__EXP:
+ setExp((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEX__DOTS:
+ setDots(DOTS_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.INDEX__END:
+ setEnd((Expression)null);
+ return;
+ case CoffeeScriptPackage.INDEX__START:
+ setStart((Expression)null);
+ return;
+ case CoffeeScriptPackage.INDEX__EXP:
+ setExp((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEX__DOTS:
+ return DOTS_EDEFAULT == null ? dots != null : !DOTS_EDEFAULT.equals(dots);
+ case CoffeeScriptPackage.INDEX__END:
+ return end != null;
+ case CoffeeScriptPackage.INDEX__START:
+ return start != null;
+ case CoffeeScriptPackage.INDEX__EXP:
+ return exp != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (dots: ");
+ result.append(dots);
+ result.append(')');
+ return result.toString();
+ }
+
+} //IndexImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/IndexedPropertyAccessImpl.java b/csep/src-gen/csep/coffeeScript/impl/IndexedPropertyAccessImpl.java
new file mode 100644
index 0000000..5bcc1ce
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/IndexedPropertyAccessImpl.java
@@ -0,0 +1,193 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Index;
+import csep.coffeeScript.IndexedPropertyAccess;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Indexed Property Access
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.IndexedPropertyAccessImpl#getIndex Index }
+ *
+ *
+ *
+ * @generated
+ */
+public class IndexedPropertyAccessImpl extends PropertyAccessImpl implements IndexedPropertyAccess
+{
+ /**
+ * The cached value of the '{@link #getIndex() Index }' containment reference.
+ *
+ *
+ * @see #getIndex()
+ * @generated
+ * @ordered
+ */
+ protected Index index;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected IndexedPropertyAccessImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.INDEXED_PROPERTY_ACCESS;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Index getIndex()
+ {
+ return index;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetIndex(Index newIndex, NotificationChain msgs)
+ {
+ Index oldIndex = index;
+ index = newIndex;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS__INDEX, oldIndex, newIndex);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setIndex(Index newIndex)
+ {
+ if (newIndex != index)
+ {
+ NotificationChain msgs = null;
+ if (index != null)
+ msgs = ((InternalEObject)index).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS__INDEX, null, msgs);
+ if (newIndex != null)
+ msgs = ((InternalEObject)newIndex).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS__INDEX, null, msgs);
+ msgs = basicSetIndex(newIndex, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS__INDEX, newIndex, newIndex));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS__INDEX:
+ return basicSetIndex(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS__INDEX:
+ return getIndex();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS__INDEX:
+ setIndex((Index)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS__INDEX:
+ setIndex((Index)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS__INDEX:
+ return index != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //IndexedPropertyAccessImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/JSLiteralImpl.java b/csep/src-gen/csep/coffeeScript/impl/JSLiteralImpl.java
new file mode 100644
index 0000000..761ff4c
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/JSLiteralImpl.java
@@ -0,0 +1,42 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.JSLiteral;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ *
+ * An implementation of the model object 'JS Literal
+ *
+ *
+ * @generated
+ */
+public class JSLiteralImpl extends LiteralImpl implements JSLiteral
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected JSLiteralImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.JS_LITERAL;
+ }
+
+} //JSLiteralImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/LambdaImpl.java b/csep/src-gen/csep/coffeeScript/impl/LambdaImpl.java
new file mode 100644
index 0000000..68dd3c3
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/LambdaImpl.java
@@ -0,0 +1,240 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Block;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Lambda;
+import csep.coffeeScript.Param;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Lambda
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.LambdaImpl#getParams Params }
+ * {@link csep.coffeeScript.impl.LambdaImpl#getBody Body }
+ *
+ *
+ *
+ * @generated
+ */
+public class LambdaImpl extends PrimaryExpressionImpl implements Lambda
+{
+ /**
+ * The cached value of the '{@link #getParams() Params }' containment reference list.
+ *
+ *
+ * @see #getParams()
+ * @generated
+ * @ordered
+ */
+ protected EListBody }' containment reference.
+ *
+ *
+ * @see #getBody()
+ * @generated
+ * @ordered
+ */
+ protected Block body;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected LambdaImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.LAMBDA;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EListLine
+ *
+ *
+ * @generated
+ */
+public class LineImpl extends MinimalEObjectImpl.Container implements Line
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected LineImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.LINE;
+ }
+
+} //LineImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/LiteralImpl.java b/csep/src-gen/csep/coffeeScript/impl/LiteralImpl.java
new file mode 100644
index 0000000..630e675
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/LiteralImpl.java
@@ -0,0 +1,42 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Literal;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ *
+ * An implementation of the model object 'Literal
+ *
+ *
+ * @generated
+ */
+public class LiteralImpl extends PrimaryExpressionImpl implements Literal
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected LiteralImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.LITERAL;
+ }
+
+} //LiteralImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/LoopImpl.java b/csep/src-gen/csep/coffeeScript/impl/LoopImpl.java
new file mode 100644
index 0000000..31e93f6
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/LoopImpl.java
@@ -0,0 +1,193 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Block;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Loop;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Loop
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.LoopImpl#getBody Body }
+ *
+ *
+ *
+ * @generated
+ */
+public class LoopImpl extends PrimaryExpressionImpl implements Loop
+{
+ /**
+ * The cached value of the '{@link #getBody() Body }' containment reference.
+ *
+ *
+ * @see #getBody()
+ * @generated
+ * @ordered
+ */
+ protected Block body;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected LoopImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.LOOP;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block getBody()
+ {
+ return body;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetBody(Block newBody, NotificationChain msgs)
+ {
+ Block oldBody = body;
+ body = newBody;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.LOOP__BODY, oldBody, newBody);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setBody(Block newBody)
+ {
+ if (newBody != body)
+ {
+ NotificationChain msgs = null;
+ if (body != null)
+ msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.LOOP__BODY, null, msgs);
+ if (newBody != null)
+ msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.LOOP__BODY, null, msgs);
+ msgs = basicSetBody(newBody, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.LOOP__BODY, newBody, newBody));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.LOOP__BODY:
+ return basicSetBody(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.LOOP__BODY:
+ return getBody();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.LOOP__BODY:
+ setBody((Block)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.LOOP__BODY:
+ setBody((Block)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.LOOP__BODY:
+ return body != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //LoopImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/NamedPropertyAccessImpl.java b/csep/src-gen/csep/coffeeScript/impl/NamedPropertyAccessImpl.java
new file mode 100644
index 0000000..8ccd42c
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/NamedPropertyAccessImpl.java
@@ -0,0 +1,264 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Id;
+import csep.coffeeScript.NamedPropertyAccess;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Named Property Access
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.NamedPropertyAccessImpl#getAccessor Accessor }
+ * {@link csep.coffeeScript.impl.NamedPropertyAccessImpl#getName Name }
+ *
+ *
+ *
+ * @generated
+ */
+public class NamedPropertyAccessImpl extends PropertyAccessImpl implements NamedPropertyAccess
+{
+ /**
+ * The default value of the '{@link #getAccessor() Accessor }' attribute.
+ *
+ *
+ * @see #getAccessor()
+ * @generated
+ * @ordered
+ */
+ protected static final String ACCESSOR_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getAccessor() Accessor }' attribute.
+ *
+ *
+ * @see #getAccessor()
+ * @generated
+ * @ordered
+ */
+ protected String accessor = ACCESSOR_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getName() Name }' containment reference.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected Id name;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected NamedPropertyAccessImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.NAMED_PROPERTY_ACCESS;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getAccessor()
+ {
+ return accessor;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setAccessor(String newAccessor)
+ {
+ String oldAccessor = accessor;
+ accessor = newAccessor;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__ACCESSOR, oldAccessor, accessor));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Id getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetName(Id newName, NotificationChain msgs)
+ {
+ Id oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__NAME, oldName, newName);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(Id newName)
+ {
+ if (newName != name)
+ {
+ NotificationChain msgs = null;
+ if (name != null)
+ msgs = ((InternalEObject)name).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__NAME, null, msgs);
+ if (newName != null)
+ msgs = ((InternalEObject)newName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__NAME, null, msgs);
+ msgs = basicSetName(newName, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__NAME, newName, newName));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__NAME:
+ return basicSetName(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__ACCESSOR:
+ return getAccessor();
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__NAME:
+ return getName();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__ACCESSOR:
+ setAccessor((String)newValue);
+ return;
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__NAME:
+ setName((Id)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__ACCESSOR:
+ setAccessor(ACCESSOR_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__NAME:
+ setName((Id)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__ACCESSOR:
+ return ACCESSOR_EDEFAULT == null ? accessor != null : !ACCESSOR_EDEFAULT.equals(accessor);
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS__NAME:
+ return name != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (accessor: ");
+ result.append(accessor);
+ result.append(')');
+ return result.toString();
+ }
+
+} //NamedPropertyAccessImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/NumberLiteralImpl.java b/csep/src-gen/csep/coffeeScript/impl/NumberLiteralImpl.java
new file mode 100644
index 0000000..fd14bae
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/NumberLiteralImpl.java
@@ -0,0 +1,42 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.NumberLiteral;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ *
+ * An implementation of the model object 'Number Literal
+ *
+ *
+ * @generated
+ */
+public class NumberLiteralImpl extends LiteralImpl implements NumberLiteral
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected NumberLiteralImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.NUMBER_LITERAL;
+ }
+
+} //NumberLiteralImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ParamImpl.java b/csep/src-gen/csep/coffeeScript/impl/ParamImpl.java
new file mode 100644
index 0000000..9c1b2bb
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ParamImpl.java
@@ -0,0 +1,44 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Param;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Param
+ *
+ *
+ * @generated
+ */
+public class ParamImpl extends MinimalEObjectImpl.Container implements Param
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ParamImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.PARAM;
+ }
+
+} //ParamImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ParentheticalImpl.java b/csep/src-gen/csep/coffeeScript/impl/ParentheticalImpl.java
new file mode 100644
index 0000000..65ebde2
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ParentheticalImpl.java
@@ -0,0 +1,193 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Body;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Parenthetical;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Parenthetical
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.ParentheticalImpl#getContent Content }
+ *
+ *
+ *
+ * @generated
+ */
+public class ParentheticalImpl extends PrimaryExpressionImpl implements Parenthetical
+{
+ /**
+ * The cached value of the '{@link #getContent() Content }' containment reference.
+ *
+ *
+ * @see #getContent()
+ * @generated
+ * @ordered
+ */
+ protected Body content;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ParentheticalImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.PARENTHETICAL;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Body getContent()
+ {
+ return content;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetContent(Body newContent, NotificationChain msgs)
+ {
+ Body oldContent = content;
+ content = newContent;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.PARENTHETICAL__CONTENT, oldContent, newContent);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setContent(Body newContent)
+ {
+ if (newContent != content)
+ {
+ NotificationChain msgs = null;
+ if (content != null)
+ msgs = ((InternalEObject)content).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.PARENTHETICAL__CONTENT, null, msgs);
+ if (newContent != null)
+ msgs = ((InternalEObject)newContent).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.PARENTHETICAL__CONTENT, null, msgs);
+ msgs = basicSetContent(newContent, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.PARENTHETICAL__CONTENT, newContent, newContent));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PARENTHETICAL__CONTENT:
+ return basicSetContent(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PARENTHETICAL__CONTENT:
+ return getContent();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PARENTHETICAL__CONTENT:
+ setContent((Body)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PARENTHETICAL__CONTENT:
+ setContent((Body)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PARENTHETICAL__CONTENT:
+ return content != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //ParentheticalImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/PrimaryExpressionImpl.java b/csep/src-gen/csep/coffeeScript/impl/PrimaryExpressionImpl.java
new file mode 100644
index 0000000..b0a2ff7
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/PrimaryExpressionImpl.java
@@ -0,0 +1,44 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.PrimaryExpression;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Primary Expression
+ *
+ *
+ * @generated
+ */
+public class PrimaryExpressionImpl extends MinimalEObjectImpl.Container implements PrimaryExpression
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected PrimaryExpressionImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.PRIMARY_EXPRESSION;
+ }
+
+} //PrimaryExpressionImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/PropertyAccessImpl.java b/csep/src-gen/csep/coffeeScript/impl/PropertyAccessImpl.java
new file mode 100644
index 0000000..e438278
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/PropertyAccessImpl.java
@@ -0,0 +1,42 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.PropertyAccess;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ *
+ * An implementation of the model object 'Property Access
+ *
+ *
+ * @generated
+ */
+public class PropertyAccessImpl extends FeatureCallImpl implements PropertyAccess
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected PropertyAccessImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.PROPERTY_ACCESS;
+ }
+
+} //PropertyAccessImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/PropertyImpl.java b/csep/src-gen/csep/coffeeScript/impl/PropertyImpl.java
new file mode 100644
index 0000000..1e16cde
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/PropertyImpl.java
@@ -0,0 +1,546 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Assignable;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.ForSource;
+import csep.coffeeScript.ForValue;
+import csep.coffeeScript.Line;
+import csep.coffeeScript.Property;
+import csep.coffeeScript.Variable;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Property
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.PropertyImpl#getIndexes Indexes }
+ * {@link csep.coffeeScript.impl.PropertyImpl#getSource Source }
+ * {@link csep.coffeeScript.impl.PropertyImpl#getLeft Left }
+ * {@link csep.coffeeScript.impl.PropertyImpl#getOperator Operator }
+ * {@link csep.coffeeScript.impl.PropertyImpl#getRight Right }
+ *
+ *
+ *
+ * @generated
+ */
+public class PropertyImpl extends SuperClassImpl implements Property
+{
+ /**
+ * The cached value of the '{@link #getIndexes() Indexes }' containment reference list.
+ *
+ *
+ * @see #getIndexes()
+ * @generated
+ * @ordered
+ */
+ protected EList indexes;
+
+ /**
+ * The cached value of the '{@link #getSource() Source }' containment reference.
+ *
+ *
+ * @see #getSource()
+ * @generated
+ * @ordered
+ */
+ protected ForSource source;
+
+ /**
+ * The cached value of the '{@link #getLeft() Left }' containment reference.
+ *
+ *
+ * @see #getLeft()
+ * @generated
+ * @ordered
+ */
+ protected EObject left;
+
+ /**
+ * The default value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected static final String OPERATOR_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getOperator() Operator }' attribute.
+ *
+ *
+ * @see #getOperator()
+ * @generated
+ * @ordered
+ */
+ protected String operator = OPERATOR_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getRight() Right }' containment reference.
+ *
+ *
+ * @see #getRight()
+ * @generated
+ * @ordered
+ */
+ protected Expression right;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected PropertyImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.PROPERTY;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getIndexes()
+ {
+ if (indexes == null)
+ {
+ indexes = new EObjectContainmentEList(ForValue.class, this, CoffeeScriptPackage.PROPERTY__INDEXES);
+ }
+ return indexes;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ForSource getSource()
+ {
+ return source;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetSource(ForSource newSource, NotificationChain msgs)
+ {
+ ForSource oldSource = source;
+ source = newSource;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.PROPERTY__SOURCE, oldSource, newSource);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSource(ForSource newSource)
+ {
+ if (newSource != source)
+ {
+ NotificationChain msgs = null;
+ if (source != null)
+ msgs = ((InternalEObject)source).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.PROPERTY__SOURCE, null, msgs);
+ if (newSource != null)
+ msgs = ((InternalEObject)newSource).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.PROPERTY__SOURCE, null, msgs);
+ msgs = basicSetSource(newSource, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.PROPERTY__SOURCE, newSource, newSource));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EObject getLeft()
+ {
+ return left;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetLeft(EObject newLeft, NotificationChain msgs)
+ {
+ EObject oldLeft = left;
+ left = newLeft;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.PROPERTY__LEFT, oldLeft, newLeft);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLeft(EObject newLeft)
+ {
+ if (newLeft != left)
+ {
+ NotificationChain msgs = null;
+ if (left != null)
+ msgs = ((InternalEObject)left).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.PROPERTY__LEFT, null, msgs);
+ if (newLeft != null)
+ msgs = ((InternalEObject)newLeft).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.PROPERTY__LEFT, null, msgs);
+ msgs = basicSetLeft(newLeft, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.PROPERTY__LEFT, newLeft, newLeft));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getOperator()
+ {
+ return operator;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setOperator(String newOperator)
+ {
+ String oldOperator = operator;
+ operator = newOperator;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.PROPERTY__OPERATOR, oldOperator, operator));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getRight()
+ {
+ return right;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetRight(Expression newRight, NotificationChain msgs)
+ {
+ Expression oldRight = right;
+ right = newRight;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.PROPERTY__RIGHT, oldRight, newRight);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRight(Expression newRight)
+ {
+ if (newRight != right)
+ {
+ NotificationChain msgs = null;
+ if (right != null)
+ msgs = ((InternalEObject)right).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.PROPERTY__RIGHT, null, msgs);
+ if (newRight != null)
+ msgs = ((InternalEObject)newRight).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.PROPERTY__RIGHT, null, msgs);
+ msgs = basicSetRight(newRight, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.PROPERTY__RIGHT, newRight, newRight));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PROPERTY__INDEXES:
+ return ((InternalEList)getIndexes()).basicRemove(otherEnd, msgs);
+ case CoffeeScriptPackage.PROPERTY__SOURCE:
+ return basicSetSource(null, msgs);
+ case CoffeeScriptPackage.PROPERTY__LEFT:
+ return basicSetLeft(null, msgs);
+ case CoffeeScriptPackage.PROPERTY__RIGHT:
+ return basicSetRight(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PROPERTY__INDEXES:
+ return getIndexes();
+ case CoffeeScriptPackage.PROPERTY__SOURCE:
+ return getSource();
+ case CoffeeScriptPackage.PROPERTY__LEFT:
+ return getLeft();
+ case CoffeeScriptPackage.PROPERTY__OPERATOR:
+ return getOperator();
+ case CoffeeScriptPackage.PROPERTY__RIGHT:
+ return getRight();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PROPERTY__INDEXES:
+ getIndexes().clear();
+ getIndexes().addAll((Collection)newValue);
+ return;
+ case CoffeeScriptPackage.PROPERTY__SOURCE:
+ setSource((ForSource)newValue);
+ return;
+ case CoffeeScriptPackage.PROPERTY__LEFT:
+ setLeft((EObject)newValue);
+ return;
+ case CoffeeScriptPackage.PROPERTY__OPERATOR:
+ setOperator((String)newValue);
+ return;
+ case CoffeeScriptPackage.PROPERTY__RIGHT:
+ setRight((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PROPERTY__INDEXES:
+ getIndexes().clear();
+ return;
+ case CoffeeScriptPackage.PROPERTY__SOURCE:
+ setSource((ForSource)null);
+ return;
+ case CoffeeScriptPackage.PROPERTY__LEFT:
+ setLeft((EObject)null);
+ return;
+ case CoffeeScriptPackage.PROPERTY__OPERATOR:
+ setOperator(OPERATOR_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.PROPERTY__RIGHT:
+ setRight((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.PROPERTY__INDEXES:
+ return indexes != null && !indexes.isEmpty();
+ case CoffeeScriptPackage.PROPERTY__SOURCE:
+ return source != null;
+ case CoffeeScriptPackage.PROPERTY__LEFT:
+ return left != null;
+ case CoffeeScriptPackage.PROPERTY__OPERATOR:
+ return OPERATOR_EDEFAULT == null ? operator != null : !OPERATOR_EDEFAULT.equals(operator);
+ case CoffeeScriptPackage.PROPERTY__RIGHT:
+ return right != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public int eBaseStructuralFeatureID(int derivedFeatureID, Class baseClass)
+ {
+ if (baseClass == Line.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Expression.class)
+ {
+ switch (derivedFeatureID)
+ {
+ case CoffeeScriptPackage.PROPERTY__INDEXES: return CoffeeScriptPackage.EXPRESSION__INDEXES;
+ case CoffeeScriptPackage.PROPERTY__SOURCE: return CoffeeScriptPackage.EXPRESSION__SOURCE;
+ case CoffeeScriptPackage.PROPERTY__LEFT: return CoffeeScriptPackage.EXPRESSION__LEFT;
+ case CoffeeScriptPackage.PROPERTY__OPERATOR: return CoffeeScriptPackage.EXPRESSION__OPERATOR;
+ case CoffeeScriptPackage.PROPERTY__RIGHT: return CoffeeScriptPackage.EXPRESSION__RIGHT;
+ default: return -1;
+ }
+ }
+ if (baseClass == Assignable.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Variable.class)
+ {
+ switch (derivedFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public int eDerivedStructuralFeatureID(int baseFeatureID, Class baseClass)
+ {
+ if (baseClass == Line.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Expression.class)
+ {
+ switch (baseFeatureID)
+ {
+ case CoffeeScriptPackage.EXPRESSION__INDEXES: return CoffeeScriptPackage.PROPERTY__INDEXES;
+ case CoffeeScriptPackage.EXPRESSION__SOURCE: return CoffeeScriptPackage.PROPERTY__SOURCE;
+ case CoffeeScriptPackage.EXPRESSION__LEFT: return CoffeeScriptPackage.PROPERTY__LEFT;
+ case CoffeeScriptPackage.EXPRESSION__OPERATOR: return CoffeeScriptPackage.PROPERTY__OPERATOR;
+ case CoffeeScriptPackage.EXPRESSION__RIGHT: return CoffeeScriptPackage.PROPERTY__RIGHT;
+ default: return -1;
+ }
+ }
+ if (baseClass == Assignable.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ if (baseClass == Variable.class)
+ {
+ switch (baseFeatureID)
+ {
+ default: return -1;
+ }
+ }
+ return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (operator: ");
+ result.append(operator);
+ result.append(')');
+ return result.toString();
+ }
+
+} //PropertyImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/RangeImpl.java b/csep/src-gen/csep/coffeeScript/impl/RangeImpl.java
new file mode 100644
index 0000000..d88ac01
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/RangeImpl.java
@@ -0,0 +1,264 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.Range;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Range
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.RangeImpl#getStart Start }
+ * {@link csep.coffeeScript.impl.RangeImpl#getEnd End }
+ *
+ *
+ *
+ * @generated
+ */
+public class RangeImpl extends PrimaryExpressionImpl implements Range
+{
+ /**
+ * The cached value of the '{@link #getStart() Start }' containment reference.
+ *
+ *
+ * @see #getStart()
+ * @generated
+ * @ordered
+ */
+ protected Expression start;
+
+ /**
+ * The cached value of the '{@link #getEnd() End }' containment reference.
+ *
+ *
+ * @see #getEnd()
+ * @generated
+ * @ordered
+ */
+ protected Expression end;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected RangeImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.RANGE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getStart()
+ {
+ return start;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetStart(Expression newStart, NotificationChain msgs)
+ {
+ Expression oldStart = start;
+ start = newStart;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.RANGE__START, oldStart, newStart);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setStart(Expression newStart)
+ {
+ if (newStart != start)
+ {
+ NotificationChain msgs = null;
+ if (start != null)
+ msgs = ((InternalEObject)start).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.RANGE__START, null, msgs);
+ if (newStart != null)
+ msgs = ((InternalEObject)newStart).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.RANGE__START, null, msgs);
+ msgs = basicSetStart(newStart, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.RANGE__START, newStart, newStart));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getEnd()
+ {
+ return end;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetEnd(Expression newEnd, NotificationChain msgs)
+ {
+ Expression oldEnd = end;
+ end = newEnd;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.RANGE__END, oldEnd, newEnd);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setEnd(Expression newEnd)
+ {
+ if (newEnd != end)
+ {
+ NotificationChain msgs = null;
+ if (end != null)
+ msgs = ((InternalEObject)end).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.RANGE__END, null, msgs);
+ if (newEnd != null)
+ msgs = ((InternalEObject)newEnd).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.RANGE__END, null, msgs);
+ msgs = basicSetEnd(newEnd, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.RANGE__END, newEnd, newEnd));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RANGE__START:
+ return basicSetStart(null, msgs);
+ case CoffeeScriptPackage.RANGE__END:
+ return basicSetEnd(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RANGE__START:
+ return getStart();
+ case CoffeeScriptPackage.RANGE__END:
+ return getEnd();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RANGE__START:
+ setStart((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.RANGE__END:
+ setEnd((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RANGE__START:
+ setStart((Expression)null);
+ return;
+ case CoffeeScriptPackage.RANGE__END:
+ setEnd((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RANGE__START:
+ return start != null;
+ case CoffeeScriptPackage.RANGE__END:
+ return end != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //RangeImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/RegexLiteralImpl.java b/csep/src-gen/csep/coffeeScript/impl/RegexLiteralImpl.java
new file mode 100644
index 0000000..3519638
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/RegexLiteralImpl.java
@@ -0,0 +1,42 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.RegexLiteral;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ *
+ * An implementation of the model object 'Regex Literal
+ *
+ *
+ * @generated
+ */
+public class RegexLiteralImpl extends LiteralImpl implements RegexLiteral
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected RegexLiteralImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.REGEX_LITERAL;
+ }
+
+} //RegexLiteralImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/RequireStmtImpl.java b/csep/src-gen/csep/coffeeScript/impl/RequireStmtImpl.java
new file mode 100644
index 0000000..9947f23
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/RequireStmtImpl.java
@@ -0,0 +1,264 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Id;
+import csep.coffeeScript.RequireStmt;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Require Stmt
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.RequireStmtImpl#getImportedNamespace Imported Namespace }
+ * {@link csep.coffeeScript.impl.RequireStmtImpl#getUri Uri }
+ *
+ *
+ *
+ * @generated
+ */
+public class RequireStmtImpl extends StmtImpl implements RequireStmt
+{
+ /**
+ * The cached value of the '{@link #getImportedNamespace() Imported Namespace }' containment reference.
+ *
+ *
+ * @see #getImportedNamespace()
+ * @generated
+ * @ordered
+ */
+ protected Id importedNamespace;
+
+ /**
+ * The default value of the '{@link #getUri() Uri }' attribute.
+ *
+ *
+ * @see #getUri()
+ * @generated
+ * @ordered
+ */
+ protected static final String URI_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getUri() Uri }' attribute.
+ *
+ *
+ * @see #getUri()
+ * @generated
+ * @ordered
+ */
+ protected String uri = URI_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected RequireStmtImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.REQUIRE_STMT;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Id getImportedNamespace()
+ {
+ return importedNamespace;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetImportedNamespace(Id newImportedNamespace, NotificationChain msgs)
+ {
+ Id oldImportedNamespace = importedNamespace;
+ importedNamespace = newImportedNamespace;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.REQUIRE_STMT__IMPORTED_NAMESPACE, oldImportedNamespace, newImportedNamespace);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setImportedNamespace(Id newImportedNamespace)
+ {
+ if (newImportedNamespace != importedNamespace)
+ {
+ NotificationChain msgs = null;
+ if (importedNamespace != null)
+ msgs = ((InternalEObject)importedNamespace).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.REQUIRE_STMT__IMPORTED_NAMESPACE, null, msgs);
+ if (newImportedNamespace != null)
+ msgs = ((InternalEObject)newImportedNamespace).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.REQUIRE_STMT__IMPORTED_NAMESPACE, null, msgs);
+ msgs = basicSetImportedNamespace(newImportedNamespace, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.REQUIRE_STMT__IMPORTED_NAMESPACE, newImportedNamespace, newImportedNamespace));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getUri()
+ {
+ return uri;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setUri(String newUri)
+ {
+ String oldUri = uri;
+ uri = newUri;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.REQUIRE_STMT__URI, oldUri, uri));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.REQUIRE_STMT__IMPORTED_NAMESPACE:
+ return basicSetImportedNamespace(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.REQUIRE_STMT__IMPORTED_NAMESPACE:
+ return getImportedNamespace();
+ case CoffeeScriptPackage.REQUIRE_STMT__URI:
+ return getUri();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.REQUIRE_STMT__IMPORTED_NAMESPACE:
+ setImportedNamespace((Id)newValue);
+ return;
+ case CoffeeScriptPackage.REQUIRE_STMT__URI:
+ setUri((String)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.REQUIRE_STMT__IMPORTED_NAMESPACE:
+ setImportedNamespace((Id)null);
+ return;
+ case CoffeeScriptPackage.REQUIRE_STMT__URI:
+ setUri(URI_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.REQUIRE_STMT__IMPORTED_NAMESPACE:
+ return importedNamespace != null;
+ case CoffeeScriptPackage.REQUIRE_STMT__URI:
+ return URI_EDEFAULT == null ? uri != null : !URI_EDEFAULT.equals(uri);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (uri: ");
+ result.append(uri);
+ result.append(')');
+ return result.toString();
+ }
+
+} //RequireStmtImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ReturnStmtImpl.java b/csep/src-gen/csep/coffeeScript/impl/ReturnStmtImpl.java
new file mode 100644
index 0000000..4d9a544
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ReturnStmtImpl.java
@@ -0,0 +1,264 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.ReturnStmt;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Return Stmt
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.ReturnStmtImpl#getExpression Expression }
+ * {@link csep.coffeeScript.impl.ReturnStmtImpl#getCondition Condition }
+ *
+ *
+ *
+ * @generated
+ */
+public class ReturnStmtImpl extends StmtImpl implements ReturnStmt
+{
+ /**
+ * The cached value of the '{@link #getExpression() Expression }' containment reference.
+ *
+ *
+ * @see #getExpression()
+ * @generated
+ * @ordered
+ */
+ protected Expression expression;
+
+ /**
+ * The cached value of the '{@link #getCondition() Condition }' containment reference.
+ *
+ *
+ * @see #getCondition()
+ * @generated
+ * @ordered
+ */
+ protected Expression condition;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ReturnStmtImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.RETURN_STMT;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getExpression()
+ {
+ return expression;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetExpression(Expression newExpression, NotificationChain msgs)
+ {
+ Expression oldExpression = expression;
+ expression = newExpression;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.RETURN_STMT__EXPRESSION, oldExpression, newExpression);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setExpression(Expression newExpression)
+ {
+ if (newExpression != expression)
+ {
+ NotificationChain msgs = null;
+ if (expression != null)
+ msgs = ((InternalEObject)expression).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.RETURN_STMT__EXPRESSION, null, msgs);
+ if (newExpression != null)
+ msgs = ((InternalEObject)newExpression).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.RETURN_STMT__EXPRESSION, null, msgs);
+ msgs = basicSetExpression(newExpression, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.RETURN_STMT__EXPRESSION, newExpression, newExpression));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getCondition()
+ {
+ return condition;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetCondition(Expression newCondition, NotificationChain msgs)
+ {
+ Expression oldCondition = condition;
+ condition = newCondition;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.RETURN_STMT__CONDITION, oldCondition, newCondition);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setCondition(Expression newCondition)
+ {
+ if (newCondition != condition)
+ {
+ NotificationChain msgs = null;
+ if (condition != null)
+ msgs = ((InternalEObject)condition).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.RETURN_STMT__CONDITION, null, msgs);
+ if (newCondition != null)
+ msgs = ((InternalEObject)newCondition).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.RETURN_STMT__CONDITION, null, msgs);
+ msgs = basicSetCondition(newCondition, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.RETURN_STMT__CONDITION, newCondition, newCondition));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RETURN_STMT__EXPRESSION:
+ return basicSetExpression(null, msgs);
+ case CoffeeScriptPackage.RETURN_STMT__CONDITION:
+ return basicSetCondition(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RETURN_STMT__EXPRESSION:
+ return getExpression();
+ case CoffeeScriptPackage.RETURN_STMT__CONDITION:
+ return getCondition();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RETURN_STMT__EXPRESSION:
+ setExpression((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.RETURN_STMT__CONDITION:
+ setCondition((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RETURN_STMT__EXPRESSION:
+ setExpression((Expression)null);
+ return;
+ case CoffeeScriptPackage.RETURN_STMT__CONDITION:
+ setCondition((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.RETURN_STMT__EXPRESSION:
+ return expression != null;
+ case CoffeeScriptPackage.RETURN_STMT__CONDITION:
+ return condition != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //ReturnStmtImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/RootImpl.java b/csep/src-gen/csep/coffeeScript/impl/RootImpl.java
new file mode 100644
index 0000000..d62890e
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/RootImpl.java
@@ -0,0 +1,44 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Root;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Root
+ *
+ *
+ * @generated
+ */
+public class RootImpl extends MinimalEObjectImpl.Container implements Root
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected RootImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.ROOT;
+ }
+
+} //RootImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/StmtImpl.java b/csep/src-gen/csep/coffeeScript/impl/StmtImpl.java
new file mode 100644
index 0000000..0f07c71
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/StmtImpl.java
@@ -0,0 +1,176 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Stmt;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Stmt
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.StmtImpl#getStatement Statement }
+ *
+ *
+ *
+ * @generated
+ */
+public class StmtImpl extends LineImpl implements Stmt
+{
+ /**
+ * The default value of the '{@link #getStatement() Statement }' attribute.
+ *
+ *
+ * @see #getStatement()
+ * @generated
+ * @ordered
+ */
+ protected static final String STATEMENT_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getStatement() Statement }' attribute.
+ *
+ *
+ * @see #getStatement()
+ * @generated
+ * @ordered
+ */
+ protected String statement = STATEMENT_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected StmtImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.STMT;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getStatement()
+ {
+ return statement;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setStatement(String newStatement)
+ {
+ String oldStatement = statement;
+ statement = newStatement;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.STMT__STATEMENT, oldStatement, statement));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.STMT__STATEMENT:
+ return getStatement();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.STMT__STATEMENT:
+ setStatement((String)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.STMT__STATEMENT:
+ setStatement(STATEMENT_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.STMT__STATEMENT:
+ return STATEMENT_EDEFAULT == null ? statement != null : !STATEMENT_EDEFAULT.equals(statement);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (statement: ");
+ result.append(statement);
+ result.append(')');
+ return result.toString();
+ }
+
+} //StmtImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/StringLiteralImpl.java b/csep/src-gen/csep/coffeeScript/impl/StringLiteralImpl.java
new file mode 100644
index 0000000..7bbda06
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/StringLiteralImpl.java
@@ -0,0 +1,42 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.StringLiteral;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ *
+ * An implementation of the model object 'String Literal
+ *
+ *
+ * @generated
+ */
+public class StringLiteralImpl extends LiteralImpl implements StringLiteral
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected StringLiteralImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.STRING_LITERAL;
+ }
+
+} //StringLiteralImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/SuperCallImpl.java b/csep/src-gen/csep/coffeeScript/impl/SuperCallImpl.java
new file mode 100644
index 0000000..3700425
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/SuperCallImpl.java
@@ -0,0 +1,193 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.ArgList;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.SuperCall;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Super Call
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.SuperCallImpl#getArgs Args }
+ *
+ *
+ *
+ * @generated
+ */
+public class SuperCallImpl extends ApplicationImpl implements SuperCall
+{
+ /**
+ * The cached value of the '{@link #getArgs() Args }' containment reference.
+ *
+ *
+ * @see #getArgs()
+ * @generated
+ * @ordered
+ */
+ protected ArgList args;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected SuperCallImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.SUPER_CALL;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ArgList getArgs()
+ {
+ return args;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetArgs(ArgList newArgs, NotificationChain msgs)
+ {
+ ArgList oldArgs = args;
+ args = newArgs;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.SUPER_CALL__ARGS, oldArgs, newArgs);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setArgs(ArgList newArgs)
+ {
+ if (newArgs != args)
+ {
+ NotificationChain msgs = null;
+ if (args != null)
+ msgs = ((InternalEObject)args).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.SUPER_CALL__ARGS, null, msgs);
+ if (newArgs != null)
+ msgs = ((InternalEObject)newArgs).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.SUPER_CALL__ARGS, null, msgs);
+ msgs = basicSetArgs(newArgs, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.SUPER_CALL__ARGS, newArgs, newArgs));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SUPER_CALL__ARGS:
+ return basicSetArgs(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SUPER_CALL__ARGS:
+ return getArgs();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SUPER_CALL__ARGS:
+ setArgs((ArgList)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SUPER_CALL__ARGS:
+ setArgs((ArgList)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SUPER_CALL__ARGS:
+ return args != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //SuperCallImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/SuperClassImpl.java b/csep/src-gen/csep/coffeeScript/impl/SuperClassImpl.java
new file mode 100644
index 0000000..181a00b
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/SuperClassImpl.java
@@ -0,0 +1,44 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.SuperClass;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Super Class
+ *
+ *
+ * @generated
+ */
+public class SuperClassImpl extends MinimalEObjectImpl.Container implements SuperClass
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected SuperClassImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.SUPER_CLASS;
+ }
+
+} //SuperClassImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/SwitchImpl.java b/csep/src-gen/csep/coffeeScript/impl/SwitchImpl.java
new file mode 100644
index 0000000..384bdd5
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/SwitchImpl.java
@@ -0,0 +1,312 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Block;
+import csep.coffeeScript.Case;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.Switch;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Switch
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.SwitchImpl#getExp Exp }
+ * {@link csep.coffeeScript.impl.SwitchImpl#getCases Cases }
+ * {@link csep.coffeeScript.impl.SwitchImpl#getElseBlock Else Block }
+ *
+ *
+ *
+ * @generated
+ */
+public class SwitchImpl extends PrimaryExpressionImpl implements Switch
+{
+ /**
+ * The cached value of the '{@link #getExp() Exp }' containment reference.
+ *
+ *
+ * @see #getExp()
+ * @generated
+ * @ordered
+ */
+ protected Expression exp;
+
+ /**
+ * The cached value of the '{@link #getCases() Cases }' containment reference list.
+ *
+ *
+ * @see #getCases()
+ * @generated
+ * @ordered
+ */
+ protected EList cases;
+
+ /**
+ * The cached value of the '{@link #getElseBlock() Else Block }' containment reference.
+ *
+ *
+ * @see #getElseBlock()
+ * @generated
+ * @ordered
+ */
+ protected Block elseBlock;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected SwitchImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.SWITCH;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getExp()
+ {
+ return exp;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetExp(Expression newExp, NotificationChain msgs)
+ {
+ Expression oldExp = exp;
+ exp = newExp;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.SWITCH__EXP, oldExp, newExp);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setExp(Expression newExp)
+ {
+ if (newExp != exp)
+ {
+ NotificationChain msgs = null;
+ if (exp != null)
+ msgs = ((InternalEObject)exp).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.SWITCH__EXP, null, msgs);
+ if (newExp != null)
+ msgs = ((InternalEObject)newExp).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.SWITCH__EXP, null, msgs);
+ msgs = basicSetExp(newExp, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.SWITCH__EXP, newExp, newExp));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getCases()
+ {
+ if (cases == null)
+ {
+ cases = new EObjectContainmentEList(Case.class, this, CoffeeScriptPackage.SWITCH__CASES);
+ }
+ return cases;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block getElseBlock()
+ {
+ return elseBlock;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetElseBlock(Block newElseBlock, NotificationChain msgs)
+ {
+ Block oldElseBlock = elseBlock;
+ elseBlock = newElseBlock;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.SWITCH__ELSE_BLOCK, oldElseBlock, newElseBlock);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setElseBlock(Block newElseBlock)
+ {
+ if (newElseBlock != elseBlock)
+ {
+ NotificationChain msgs = null;
+ if (elseBlock != null)
+ msgs = ((InternalEObject)elseBlock).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.SWITCH__ELSE_BLOCK, null, msgs);
+ if (newElseBlock != null)
+ msgs = ((InternalEObject)newElseBlock).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.SWITCH__ELSE_BLOCK, null, msgs);
+ msgs = basicSetElseBlock(newElseBlock, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.SWITCH__ELSE_BLOCK, newElseBlock, newElseBlock));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SWITCH__EXP:
+ return basicSetExp(null, msgs);
+ case CoffeeScriptPackage.SWITCH__CASES:
+ return ((InternalEList)getCases()).basicRemove(otherEnd, msgs);
+ case CoffeeScriptPackage.SWITCH__ELSE_BLOCK:
+ return basicSetElseBlock(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SWITCH__EXP:
+ return getExp();
+ case CoffeeScriptPackage.SWITCH__CASES:
+ return getCases();
+ case CoffeeScriptPackage.SWITCH__ELSE_BLOCK:
+ return getElseBlock();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SWITCH__EXP:
+ setExp((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.SWITCH__CASES:
+ getCases().clear();
+ getCases().addAll((Collection)newValue);
+ return;
+ case CoffeeScriptPackage.SWITCH__ELSE_BLOCK:
+ setElseBlock((Block)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SWITCH__EXP:
+ setExp((Expression)null);
+ return;
+ case CoffeeScriptPackage.SWITCH__CASES:
+ getCases().clear();
+ return;
+ case CoffeeScriptPackage.SWITCH__ELSE_BLOCK:
+ setElseBlock((Block)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.SWITCH__EXP:
+ return exp != null;
+ case CoffeeScriptPackage.SWITCH__CASES:
+ return cases != null && !cases.isEmpty();
+ case CoffeeScriptPackage.SWITCH__ELSE_BLOCK:
+ return elseBlock != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //SwitchImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ThisAloneImpl.java b/csep/src-gen/csep/coffeeScript/impl/ThisAloneImpl.java
new file mode 100644
index 0000000..eab0579
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ThisAloneImpl.java
@@ -0,0 +1,42 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.ThisAlone;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ *
+ * An implementation of the model object 'This Alone
+ *
+ *
+ * @generated
+ */
+public class ThisAloneImpl extends PrimaryExpressionImpl implements ThisAlone
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ThisAloneImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.THIS_ALONE;
+ }
+
+} //ThisAloneImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ThisPropertyImpl.java b/csep/src-gen/csep/coffeeScript/impl/ThisPropertyImpl.java
new file mode 100644
index 0000000..226a064
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ThisPropertyImpl.java
@@ -0,0 +1,264 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.ThisProperty;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'This Property
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.ThisPropertyImpl#isSplat Splat }
+ * {@link csep.coffeeScript.impl.ThisPropertyImpl#getDefaultValue Default Value }
+ *
+ *
+ *
+ * @generated
+ */
+public class ThisPropertyImpl extends PrimaryExpressionImpl implements ThisProperty
+{
+ /**
+ * The default value of the '{@link #isSplat() Splat }' attribute.
+ *
+ *
+ * @see #isSplat()
+ * @generated
+ * @ordered
+ */
+ protected static final boolean SPLAT_EDEFAULT = false;
+
+ /**
+ * The cached value of the '{@link #isSplat() Splat }' attribute.
+ *
+ *
+ * @see #isSplat()
+ * @generated
+ * @ordered
+ */
+ protected boolean splat = SPLAT_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getDefaultValue() Default Value }' containment reference.
+ *
+ *
+ * @see #getDefaultValue()
+ * @generated
+ * @ordered
+ */
+ protected Expression defaultValue;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ThisPropertyImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.THIS_PROPERTY;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public boolean isSplat()
+ {
+ return splat;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSplat(boolean newSplat)
+ {
+ boolean oldSplat = splat;
+ splat = newSplat;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.THIS_PROPERTY__SPLAT, oldSplat, splat));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getDefaultValue()
+ {
+ return defaultValue;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDefaultValue(Expression newDefaultValue, NotificationChain msgs)
+ {
+ Expression oldDefaultValue = defaultValue;
+ defaultValue = newDefaultValue;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE, oldDefaultValue, newDefaultValue);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDefaultValue(Expression newDefaultValue)
+ {
+ if (newDefaultValue != defaultValue)
+ {
+ NotificationChain msgs = null;
+ if (defaultValue != null)
+ msgs = ((InternalEObject)defaultValue).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE, null, msgs);
+ if (newDefaultValue != null)
+ msgs = ((InternalEObject)newDefaultValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE, null, msgs);
+ msgs = basicSetDefaultValue(newDefaultValue, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE, newDefaultValue, newDefaultValue));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE:
+ return basicSetDefaultValue(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THIS_PROPERTY__SPLAT:
+ return isSplat();
+ case CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE:
+ return getDefaultValue();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THIS_PROPERTY__SPLAT:
+ setSplat((Boolean)newValue);
+ return;
+ case CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE:
+ setDefaultValue((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THIS_PROPERTY__SPLAT:
+ setSplat(SPLAT_EDEFAULT);
+ return;
+ case CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE:
+ setDefaultValue((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THIS_PROPERTY__SPLAT:
+ return splat != SPLAT_EDEFAULT;
+ case CoffeeScriptPackage.THIS_PROPERTY__DEFAULT_VALUE:
+ return defaultValue != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (splat: ");
+ result.append(splat);
+ result.append(')');
+ return result.toString();
+ }
+
+} //ThisPropertyImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/ThrowStmtImpl.java b/csep/src-gen/csep/coffeeScript/impl/ThrowStmtImpl.java
new file mode 100644
index 0000000..d1387a7
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/ThrowStmtImpl.java
@@ -0,0 +1,193 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.ThrowStmt;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Throw Stmt
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.ThrowStmtImpl#getExp Exp }
+ *
+ *
+ *
+ * @generated
+ */
+public class ThrowStmtImpl extends StmtImpl implements ThrowStmt
+{
+ /**
+ * The cached value of the '{@link #getExp() Exp }' containment reference.
+ *
+ *
+ * @see #getExp()
+ * @generated
+ * @ordered
+ */
+ protected Expression exp;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ThrowStmtImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.THROW_STMT;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getExp()
+ {
+ return exp;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetExp(Expression newExp, NotificationChain msgs)
+ {
+ Expression oldExp = exp;
+ exp = newExp;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.THROW_STMT__EXP, oldExp, newExp);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setExp(Expression newExp)
+ {
+ if (newExp != exp)
+ {
+ NotificationChain msgs = null;
+ if (exp != null)
+ msgs = ((InternalEObject)exp).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.THROW_STMT__EXP, null, msgs);
+ if (newExp != null)
+ msgs = ((InternalEObject)newExp).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.THROW_STMT__EXP, null, msgs);
+ msgs = basicSetExp(newExp, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.THROW_STMT__EXP, newExp, newExp));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THROW_STMT__EXP:
+ return basicSetExp(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THROW_STMT__EXP:
+ return getExp();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THROW_STMT__EXP:
+ setExp((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THROW_STMT__EXP:
+ setExp((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.THROW_STMT__EXP:
+ return exp != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //ThrowStmtImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/TryCatchImpl.java b/csep/src-gen/csep/coffeeScript/impl/TryCatchImpl.java
new file mode 100644
index 0000000..99048d3
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/TryCatchImpl.java
@@ -0,0 +1,407 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.Block;
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Id;
+import csep.coffeeScript.TryCatch;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Try Catch
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.TryCatchImpl#getBody Body }
+ * {@link csep.coffeeScript.impl.TryCatchImpl#getException Exception }
+ * {@link csep.coffeeScript.impl.TryCatchImpl#getCatchBlock Catch Block }
+ * {@link csep.coffeeScript.impl.TryCatchImpl#getFinallyBlock Finally Block }
+ *
+ *
+ *
+ * @generated
+ */
+public class TryCatchImpl extends PrimaryExpressionImpl implements TryCatch
+{
+ /**
+ * The cached value of the '{@link #getBody() Body }' containment reference.
+ *
+ *
+ * @see #getBody()
+ * @generated
+ * @ordered
+ */
+ protected Block body;
+
+ /**
+ * The cached value of the '{@link #getException() Exception }' containment reference.
+ *
+ *
+ * @see #getException()
+ * @generated
+ * @ordered
+ */
+ protected Id exception;
+
+ /**
+ * The cached value of the '{@link #getCatchBlock() Catch Block }' containment reference.
+ *
+ *
+ * @see #getCatchBlock()
+ * @generated
+ * @ordered
+ */
+ protected Block catchBlock;
+
+ /**
+ * The cached value of the '{@link #getFinallyBlock() Finally Block }' containment reference.
+ *
+ *
+ * @see #getFinallyBlock()
+ * @generated
+ * @ordered
+ */
+ protected Block finallyBlock;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected TryCatchImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.TRY_CATCH;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block getBody()
+ {
+ return body;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetBody(Block newBody, NotificationChain msgs)
+ {
+ Block oldBody = body;
+ body = newBody;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.TRY_CATCH__BODY, oldBody, newBody);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setBody(Block newBody)
+ {
+ if (newBody != body)
+ {
+ NotificationChain msgs = null;
+ if (body != null)
+ msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.TRY_CATCH__BODY, null, msgs);
+ if (newBody != null)
+ msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.TRY_CATCH__BODY, null, msgs);
+ msgs = basicSetBody(newBody, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.TRY_CATCH__BODY, newBody, newBody));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Id getException()
+ {
+ return exception;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetException(Id newException, NotificationChain msgs)
+ {
+ Id oldException = exception;
+ exception = newException;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.TRY_CATCH__EXCEPTION, oldException, newException);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setException(Id newException)
+ {
+ if (newException != exception)
+ {
+ NotificationChain msgs = null;
+ if (exception != null)
+ msgs = ((InternalEObject)exception).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.TRY_CATCH__EXCEPTION, null, msgs);
+ if (newException != null)
+ msgs = ((InternalEObject)newException).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.TRY_CATCH__EXCEPTION, null, msgs);
+ msgs = basicSetException(newException, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.TRY_CATCH__EXCEPTION, newException, newException));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block getCatchBlock()
+ {
+ return catchBlock;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetCatchBlock(Block newCatchBlock, NotificationChain msgs)
+ {
+ Block oldCatchBlock = catchBlock;
+ catchBlock = newCatchBlock;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.TRY_CATCH__CATCH_BLOCK, oldCatchBlock, newCatchBlock);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setCatchBlock(Block newCatchBlock)
+ {
+ if (newCatchBlock != catchBlock)
+ {
+ NotificationChain msgs = null;
+ if (catchBlock != null)
+ msgs = ((InternalEObject)catchBlock).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.TRY_CATCH__CATCH_BLOCK, null, msgs);
+ if (newCatchBlock != null)
+ msgs = ((InternalEObject)newCatchBlock).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.TRY_CATCH__CATCH_BLOCK, null, msgs);
+ msgs = basicSetCatchBlock(newCatchBlock, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.TRY_CATCH__CATCH_BLOCK, newCatchBlock, newCatchBlock));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block getFinallyBlock()
+ {
+ return finallyBlock;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetFinallyBlock(Block newFinallyBlock, NotificationChain msgs)
+ {
+ Block oldFinallyBlock = finallyBlock;
+ finallyBlock = newFinallyBlock;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.TRY_CATCH__FINALLY_BLOCK, oldFinallyBlock, newFinallyBlock);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setFinallyBlock(Block newFinallyBlock)
+ {
+ if (newFinallyBlock != finallyBlock)
+ {
+ NotificationChain msgs = null;
+ if (finallyBlock != null)
+ msgs = ((InternalEObject)finallyBlock).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.TRY_CATCH__FINALLY_BLOCK, null, msgs);
+ if (newFinallyBlock != null)
+ msgs = ((InternalEObject)newFinallyBlock).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.TRY_CATCH__FINALLY_BLOCK, null, msgs);
+ msgs = basicSetFinallyBlock(newFinallyBlock, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.TRY_CATCH__FINALLY_BLOCK, newFinallyBlock, newFinallyBlock));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.TRY_CATCH__BODY:
+ return basicSetBody(null, msgs);
+ case CoffeeScriptPackage.TRY_CATCH__EXCEPTION:
+ return basicSetException(null, msgs);
+ case CoffeeScriptPackage.TRY_CATCH__CATCH_BLOCK:
+ return basicSetCatchBlock(null, msgs);
+ case CoffeeScriptPackage.TRY_CATCH__FINALLY_BLOCK:
+ return basicSetFinallyBlock(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.TRY_CATCH__BODY:
+ return getBody();
+ case CoffeeScriptPackage.TRY_CATCH__EXCEPTION:
+ return getException();
+ case CoffeeScriptPackage.TRY_CATCH__CATCH_BLOCK:
+ return getCatchBlock();
+ case CoffeeScriptPackage.TRY_CATCH__FINALLY_BLOCK:
+ return getFinallyBlock();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.TRY_CATCH__BODY:
+ setBody((Block)newValue);
+ return;
+ case CoffeeScriptPackage.TRY_CATCH__EXCEPTION:
+ setException((Id)newValue);
+ return;
+ case CoffeeScriptPackage.TRY_CATCH__CATCH_BLOCK:
+ setCatchBlock((Block)newValue);
+ return;
+ case CoffeeScriptPackage.TRY_CATCH__FINALLY_BLOCK:
+ setFinallyBlock((Block)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.TRY_CATCH__BODY:
+ setBody((Block)null);
+ return;
+ case CoffeeScriptPackage.TRY_CATCH__EXCEPTION:
+ setException((Id)null);
+ return;
+ case CoffeeScriptPackage.TRY_CATCH__CATCH_BLOCK:
+ setCatchBlock((Block)null);
+ return;
+ case CoffeeScriptPackage.TRY_CATCH__FINALLY_BLOCK:
+ setFinallyBlock((Block)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.TRY_CATCH__BODY:
+ return body != null;
+ case CoffeeScriptPackage.TRY_CATCH__EXCEPTION:
+ return exception != null;
+ case CoffeeScriptPackage.TRY_CATCH__CATCH_BLOCK:
+ return catchBlock != null;
+ case CoffeeScriptPackage.TRY_CATCH__FINALLY_BLOCK:
+ return finallyBlock != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //TryCatchImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/UntilImpl.java b/csep/src-gen/csep/coffeeScript/impl/UntilImpl.java
new file mode 100644
index 0000000..e48ed2d
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/UntilImpl.java
@@ -0,0 +1,407 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.Until;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'Until
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.UntilImpl#getDummy Dummy }
+ * {@link csep.coffeeScript.impl.UntilImpl#getBody Body }
+ * {@link csep.coffeeScript.impl.UntilImpl#getWhen When }
+ * {@link csep.coffeeScript.impl.UntilImpl#getLoop Loop }
+ *
+ *
+ *
+ * @generated
+ */
+public class UntilImpl extends ExpressionImpl implements Until
+{
+ /**
+ * The cached value of the '{@link #getDummy() Dummy }' containment reference.
+ *
+ *
+ * @see #getDummy()
+ * @generated
+ * @ordered
+ */
+ protected Expression dummy;
+
+ /**
+ * The cached value of the '{@link #getBody() Body }' containment reference.
+ *
+ *
+ * @see #getBody()
+ * @generated
+ * @ordered
+ */
+ protected EObject body;
+
+ /**
+ * The cached value of the '{@link #getWhen() When }' containment reference.
+ *
+ *
+ * @see #getWhen()
+ * @generated
+ * @ordered
+ */
+ protected Expression when;
+
+ /**
+ * The cached value of the '{@link #getLoop() Loop }' containment reference.
+ *
+ *
+ * @see #getLoop()
+ * @generated
+ * @ordered
+ */
+ protected Expression loop;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected UntilImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.UNTIL;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getDummy()
+ {
+ return dummy;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDummy(Expression newDummy, NotificationChain msgs)
+ {
+ Expression oldDummy = dummy;
+ dummy = newDummy;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.UNTIL__DUMMY, oldDummy, newDummy);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDummy(Expression newDummy)
+ {
+ if (newDummy != dummy)
+ {
+ NotificationChain msgs = null;
+ if (dummy != null)
+ msgs = ((InternalEObject)dummy).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.UNTIL__DUMMY, null, msgs);
+ if (newDummy != null)
+ msgs = ((InternalEObject)newDummy).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.UNTIL__DUMMY, null, msgs);
+ msgs = basicSetDummy(newDummy, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.UNTIL__DUMMY, newDummy, newDummy));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EObject getBody()
+ {
+ return body;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetBody(EObject newBody, NotificationChain msgs)
+ {
+ EObject oldBody = body;
+ body = newBody;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.UNTIL__BODY, oldBody, newBody);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setBody(EObject newBody)
+ {
+ if (newBody != body)
+ {
+ NotificationChain msgs = null;
+ if (body != null)
+ msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.UNTIL__BODY, null, msgs);
+ if (newBody != null)
+ msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.UNTIL__BODY, null, msgs);
+ msgs = basicSetBody(newBody, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.UNTIL__BODY, newBody, newBody));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getWhen()
+ {
+ return when;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetWhen(Expression newWhen, NotificationChain msgs)
+ {
+ Expression oldWhen = when;
+ when = newWhen;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.UNTIL__WHEN, oldWhen, newWhen);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setWhen(Expression newWhen)
+ {
+ if (newWhen != when)
+ {
+ NotificationChain msgs = null;
+ if (when != null)
+ msgs = ((InternalEObject)when).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.UNTIL__WHEN, null, msgs);
+ if (newWhen != null)
+ msgs = ((InternalEObject)newWhen).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.UNTIL__WHEN, null, msgs);
+ msgs = basicSetWhen(newWhen, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.UNTIL__WHEN, newWhen, newWhen));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getLoop()
+ {
+ return loop;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetLoop(Expression newLoop, NotificationChain msgs)
+ {
+ Expression oldLoop = loop;
+ loop = newLoop;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.UNTIL__LOOP, oldLoop, newLoop);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLoop(Expression newLoop)
+ {
+ if (newLoop != loop)
+ {
+ NotificationChain msgs = null;
+ if (loop != null)
+ msgs = ((InternalEObject)loop).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.UNTIL__LOOP, null, msgs);
+ if (newLoop != null)
+ msgs = ((InternalEObject)newLoop).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.UNTIL__LOOP, null, msgs);
+ msgs = basicSetLoop(newLoop, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.UNTIL__LOOP, newLoop, newLoop));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.UNTIL__DUMMY:
+ return basicSetDummy(null, msgs);
+ case CoffeeScriptPackage.UNTIL__BODY:
+ return basicSetBody(null, msgs);
+ case CoffeeScriptPackage.UNTIL__WHEN:
+ return basicSetWhen(null, msgs);
+ case CoffeeScriptPackage.UNTIL__LOOP:
+ return basicSetLoop(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.UNTIL__DUMMY:
+ return getDummy();
+ case CoffeeScriptPackage.UNTIL__BODY:
+ return getBody();
+ case CoffeeScriptPackage.UNTIL__WHEN:
+ return getWhen();
+ case CoffeeScriptPackage.UNTIL__LOOP:
+ return getLoop();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.UNTIL__DUMMY:
+ setDummy((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.UNTIL__BODY:
+ setBody((EObject)newValue);
+ return;
+ case CoffeeScriptPackage.UNTIL__WHEN:
+ setWhen((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.UNTIL__LOOP:
+ setLoop((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.UNTIL__DUMMY:
+ setDummy((Expression)null);
+ return;
+ case CoffeeScriptPackage.UNTIL__BODY:
+ setBody((EObject)null);
+ return;
+ case CoffeeScriptPackage.UNTIL__WHEN:
+ setWhen((Expression)null);
+ return;
+ case CoffeeScriptPackage.UNTIL__LOOP:
+ setLoop((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.UNTIL__DUMMY:
+ return dummy != null;
+ case CoffeeScriptPackage.UNTIL__BODY:
+ return body != null;
+ case CoffeeScriptPackage.UNTIL__WHEN:
+ return when != null;
+ case CoffeeScriptPackage.UNTIL__LOOP:
+ return loop != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //UntilImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/VariableImpl.java b/csep/src-gen/csep/coffeeScript/impl/VariableImpl.java
new file mode 100644
index 0000000..4171b1c
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/VariableImpl.java
@@ -0,0 +1,42 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Variable;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ *
+ * An implementation of the model object 'Variable
+ *
+ *
+ * @generated
+ */
+public class VariableImpl extends ExpressionImpl implements Variable
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected VariableImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.VARIABLE;
+ }
+
+} //VariableImpl
diff --git a/csep/src-gen/csep/coffeeScript/impl/WhileImpl.java b/csep/src-gen/csep/coffeeScript/impl/WhileImpl.java
new file mode 100644
index 0000000..97a96c2
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/impl/WhileImpl.java
@@ -0,0 +1,407 @@
+/**
+ */
+package csep.coffeeScript.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+import csep.coffeeScript.Expression;
+import csep.coffeeScript.While;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+/**
+ *
+ * An implementation of the model object 'While
+ * The following features are implemented:
+ *
+ * {@link csep.coffeeScript.impl.WhileImpl#getDummy Dummy }
+ * {@link csep.coffeeScript.impl.WhileImpl#getBody Body }
+ * {@link csep.coffeeScript.impl.WhileImpl#getWhen When }
+ * {@link csep.coffeeScript.impl.WhileImpl#getLoop Loop }
+ *
+ *
+ *
+ * @generated
+ */
+public class WhileImpl extends ExpressionImpl implements While
+{
+ /**
+ * The cached value of the '{@link #getDummy() Dummy }' containment reference.
+ *
+ *
+ * @see #getDummy()
+ * @generated
+ * @ordered
+ */
+ protected Expression dummy;
+
+ /**
+ * The cached value of the '{@link #getBody() Body }' containment reference.
+ *
+ *
+ * @see #getBody()
+ * @generated
+ * @ordered
+ */
+ protected EObject body;
+
+ /**
+ * The cached value of the '{@link #getWhen() When }' containment reference.
+ *
+ *
+ * @see #getWhen()
+ * @generated
+ * @ordered
+ */
+ protected Expression when;
+
+ /**
+ * The cached value of the '{@link #getLoop() Loop }' containment reference.
+ *
+ *
+ * @see #getLoop()
+ * @generated
+ * @ordered
+ */
+ protected Expression loop;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected WhileImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CoffeeScriptPackage.Literals.WHILE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getDummy()
+ {
+ return dummy;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDummy(Expression newDummy, NotificationChain msgs)
+ {
+ Expression oldDummy = dummy;
+ dummy = newDummy;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.WHILE__DUMMY, oldDummy, newDummy);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDummy(Expression newDummy)
+ {
+ if (newDummy != dummy)
+ {
+ NotificationChain msgs = null;
+ if (dummy != null)
+ msgs = ((InternalEObject)dummy).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.WHILE__DUMMY, null, msgs);
+ if (newDummy != null)
+ msgs = ((InternalEObject)newDummy).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.WHILE__DUMMY, null, msgs);
+ msgs = basicSetDummy(newDummy, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.WHILE__DUMMY, newDummy, newDummy));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EObject getBody()
+ {
+ return body;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetBody(EObject newBody, NotificationChain msgs)
+ {
+ EObject oldBody = body;
+ body = newBody;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.WHILE__BODY, oldBody, newBody);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setBody(EObject newBody)
+ {
+ if (newBody != body)
+ {
+ NotificationChain msgs = null;
+ if (body != null)
+ msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.WHILE__BODY, null, msgs);
+ if (newBody != null)
+ msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.WHILE__BODY, null, msgs);
+ msgs = basicSetBody(newBody, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.WHILE__BODY, newBody, newBody));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getWhen()
+ {
+ return when;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetWhen(Expression newWhen, NotificationChain msgs)
+ {
+ Expression oldWhen = when;
+ when = newWhen;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.WHILE__WHEN, oldWhen, newWhen);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setWhen(Expression newWhen)
+ {
+ if (newWhen != when)
+ {
+ NotificationChain msgs = null;
+ if (when != null)
+ msgs = ((InternalEObject)when).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.WHILE__WHEN, null, msgs);
+ if (newWhen != null)
+ msgs = ((InternalEObject)newWhen).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.WHILE__WHEN, null, msgs);
+ msgs = basicSetWhen(newWhen, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.WHILE__WHEN, newWhen, newWhen));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Expression getLoop()
+ {
+ return loop;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetLoop(Expression newLoop, NotificationChain msgs)
+ {
+ Expression oldLoop = loop;
+ loop = newLoop;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.WHILE__LOOP, oldLoop, newLoop);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLoop(Expression newLoop)
+ {
+ if (newLoop != loop)
+ {
+ NotificationChain msgs = null;
+ if (loop != null)
+ msgs = ((InternalEObject)loop).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.WHILE__LOOP, null, msgs);
+ if (newLoop != null)
+ msgs = ((InternalEObject)newLoop).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CoffeeScriptPackage.WHILE__LOOP, null, msgs);
+ msgs = basicSetLoop(newLoop, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CoffeeScriptPackage.WHILE__LOOP, newLoop, newLoop));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.WHILE__DUMMY:
+ return basicSetDummy(null, msgs);
+ case CoffeeScriptPackage.WHILE__BODY:
+ return basicSetBody(null, msgs);
+ case CoffeeScriptPackage.WHILE__WHEN:
+ return basicSetWhen(null, msgs);
+ case CoffeeScriptPackage.WHILE__LOOP:
+ return basicSetLoop(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.WHILE__DUMMY:
+ return getDummy();
+ case CoffeeScriptPackage.WHILE__BODY:
+ return getBody();
+ case CoffeeScriptPackage.WHILE__WHEN:
+ return getWhen();
+ case CoffeeScriptPackage.WHILE__LOOP:
+ return getLoop();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.WHILE__DUMMY:
+ setDummy((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.WHILE__BODY:
+ setBody((EObject)newValue);
+ return;
+ case CoffeeScriptPackage.WHILE__WHEN:
+ setWhen((Expression)newValue);
+ return;
+ case CoffeeScriptPackage.WHILE__LOOP:
+ setLoop((Expression)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.WHILE__DUMMY:
+ setDummy((Expression)null);
+ return;
+ case CoffeeScriptPackage.WHILE__BODY:
+ setBody((EObject)null);
+ return;
+ case CoffeeScriptPackage.WHILE__WHEN:
+ setWhen((Expression)null);
+ return;
+ case CoffeeScriptPackage.WHILE__LOOP:
+ setLoop((Expression)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CoffeeScriptPackage.WHILE__DUMMY:
+ return dummy != null;
+ case CoffeeScriptPackage.WHILE__BODY:
+ return body != null;
+ case CoffeeScriptPackage.WHILE__WHEN:
+ return when != null;
+ case CoffeeScriptPackage.WHILE__LOOP:
+ return loop != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //WhileImpl
diff --git a/csep/src-gen/csep/coffeeScript/util/CoffeeScriptAdapterFactory.java b/csep/src-gen/csep/coffeeScript/util/CoffeeScriptAdapterFactory.java
new file mode 100644
index 0000000..a9dc1fe
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/util/CoffeeScriptAdapterFactory.java
@@ -0,0 +1,1432 @@
+/**
+ */
+package csep.coffeeScript.util;
+
+import csep.coffeeScript.*;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ *
+ * The Adapter Factory for the model.
+ * It provides an adapter createXXX method for each class of the model.
+ *
+ * @see csep.coffeeScript.CoffeeScriptPackage
+ * @generated
+ */
+public class CoffeeScriptAdapterFactory extends AdapterFactoryImpl
+{
+ /**
+ * The cached model package.
+ *
+ *
+ * @generated
+ */
+ protected static CoffeeScriptPackage modelPackage;
+
+ /**
+ * Creates an instance of the adapter factory.
+ *
+ *
+ * @generated
+ */
+ public CoffeeScriptAdapterFactory()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = CoffeeScriptPackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Returns whether this factory is applicable for the type of the object.
+ *
+ * This implementation returns true if the object is either the model's package or is an instance object of the model.
+ *
+ * @return whether this factory is applicable for the type of the object.
+ * @generated
+ */
+ @Override
+ public boolean isFactoryForType(Object object)
+ {
+ if (object == modelPackage)
+ {
+ return true;
+ }
+ if (object instanceof EObject)
+ {
+ return ((EObject)object).eClass().getEPackage() == modelPackage;
+ }
+ return false;
+ }
+
+ /**
+ * The switch that delegates to the createXXX methods.
+ *
+ *
+ * @generated
+ */
+ protected CoffeeScriptSwitch modelSwitch =
+ new CoffeeScriptSwitch()
+ {
+ @Override
+ public Adapter caseRoot(Root object)
+ {
+ return createRootAdapter();
+ }
+ @Override
+ public Adapter caseBody(Body object)
+ {
+ return createBodyAdapter();
+ }
+ @Override
+ public Adapter caseLine(Line object)
+ {
+ return createLineAdapter();
+ }
+ @Override
+ public Adapter caseStmt(Stmt object)
+ {
+ return createStmtAdapter();
+ }
+ @Override
+ public Adapter caseComment(Comment object)
+ {
+ return createCommentAdapter();
+ }
+ @Override
+ public Adapter caseRequireStmt(RequireStmt object)
+ {
+ return createRequireStmtAdapter();
+ }
+ @Override
+ public Adapter caseReturnStmt(ReturnStmt object)
+ {
+ return createReturnStmtAdapter();
+ }
+ @Override
+ public Adapter caseThrowStmt(ThrowStmt object)
+ {
+ return createThrowStmtAdapter();
+ }
+ @Override
+ public Adapter caseSuperClass(SuperClass object)
+ {
+ return createSuperClassAdapter();
+ }
+ @Override
+ public Adapter caseClassDeclaration(ClassDeclaration object)
+ {
+ return createClassDeclarationAdapter();
+ }
+ @Override
+ public Adapter caseAssignedClassDeclaration(AssignedClassDeclaration object)
+ {
+ return createAssignedClassDeclarationAdapter();
+ }
+ @Override
+ public Adapter caseExpression(Expression object)
+ {
+ return createExpressionAdapter();
+ }
+ @Override
+ public Adapter caseForValue(ForValue object)
+ {
+ return createForValueAdapter();
+ }
+ @Override
+ public Adapter caseForSource(ForSource object)
+ {
+ return createForSourceAdapter();
+ }
+ @Override
+ public Adapter caseRange(Range object)
+ {
+ return createRangeAdapter();
+ }
+ @Override
+ public Adapter caseApplication(Application object)
+ {
+ return createApplicationAdapter();
+ }
+ @Override
+ public Adapter caseFeatureCall(FeatureCall object)
+ {
+ return createFeatureCallAdapter();
+ }
+ @Override
+ public Adapter caseFunctionCall(FunctionCall object)
+ {
+ return createFunctionCallAdapter();
+ }
+ @Override
+ public Adapter casePropertyAccess(PropertyAccess object)
+ {
+ return createPropertyAccessAdapter();
+ }
+ @Override
+ public Adapter caseThisProperty(ThisProperty object)
+ {
+ return createThisPropertyAdapter();
+ }
+ @Override
+ public Adapter caseNamedPropertyAccess(NamedPropertyAccess object)
+ {
+ return createNamedPropertyAccessAdapter();
+ }
+ @Override
+ public Adapter caseIndexedPropertyAccess(IndexedPropertyAccess object)
+ {
+ return createIndexedPropertyAccessAdapter();
+ }
+ @Override
+ public Adapter caseIndex(Index object)
+ {
+ return createIndexAdapter();
+ }
+ @Override
+ public Adapter casePrimaryExpression(PrimaryExpression object)
+ {
+ return createPrimaryExpressionAdapter();
+ }
+ @Override
+ public Adapter caseBlock(Block object)
+ {
+ return createBlockAdapter();
+ }
+ @Override
+ public Adapter caseCase(Case object)
+ {
+ return createCaseAdapter();
+ }
+ @Override
+ public Adapter caseIfExp(IfExp object)
+ {
+ return createIfExpAdapter();
+ }
+ @Override
+ public Adapter caseCondBlock(CondBlock object)
+ {
+ return createCondBlockAdapter();
+ }
+ @Override
+ public Adapter caseIdRef(IdRef object)
+ {
+ return createIdRefAdapter();
+ }
+ @Override
+ public Adapter caseId(Id object)
+ {
+ return createIdAdapter();
+ }
+ @Override
+ public Adapter caseProperty(Property object)
+ {
+ return createPropertyAdapter();
+ }
+ @Override
+ public Adapter caseVariable(Variable object)
+ {
+ return createVariableAdapter();
+ }
+ @Override
+ public Adapter caseAssignableArray(AssignableArray object)
+ {
+ return createAssignableArrayAdapter();
+ }
+ @Override
+ public Adapter caseAssignableArgList(AssignableArgList object)
+ {
+ return createAssignableArgListAdapter();
+ }
+ @Override
+ public Adapter caseAssignableArg(AssignableArg object)
+ {
+ return createAssignableArgAdapter();
+ }
+ @Override
+ public Adapter caseAssignable(Assignable object)
+ {
+ return createAssignableAdapter();
+ }
+ @Override
+ public Adapter caseArg(Arg object)
+ {
+ return createArgAdapter();
+ }
+ @Override
+ public Adapter caseArgLine(ArgLine object)
+ {
+ return createArgLineAdapter();
+ }
+ @Override
+ public Adapter caseExplicitArgList(ExplicitArgList object)
+ {
+ return createExplicitArgListAdapter();
+ }
+ @Override
+ public Adapter caseArgList(ArgList object)
+ {
+ return createArgListAdapter();
+ }
+ @Override
+ public Adapter caseArray(Array object)
+ {
+ return createArrayAdapter();
+ }
+ @Override
+ public Adapter caseDictionary(Dictionary object)
+ {
+ return createDictionaryAdapter();
+ }
+ @Override
+ public Adapter caseDictItems(DictItems object)
+ {
+ return createDictItemsAdapter();
+ }
+ @Override
+ public Adapter caseExplicitDictItems(ExplicitDictItems object)
+ {
+ return createExplicitDictItemsAdapter();
+ }
+ @Override
+ public Adapter caseDictLine(DictLine object)
+ {
+ return createDictLineAdapter();
+ }
+ @Override
+ public Adapter caseDictItem(DictItem object)
+ {
+ return createDictItemAdapter();
+ }
+ @Override
+ public Adapter caseDictKey(DictKey object)
+ {
+ return createDictKeyAdapter();
+ }
+ @Override
+ public Adapter caseLambda(Lambda object)
+ {
+ return createLambdaAdapter();
+ }
+ @Override
+ public Adapter caseParam(Param object)
+ {
+ return createParamAdapter();
+ }
+ @Override
+ public Adapter caseNumberLiteral(NumberLiteral object)
+ {
+ return createNumberLiteralAdapter();
+ }
+ @Override
+ public Adapter caseStringLiteral(StringLiteral object)
+ {
+ return createStringLiteralAdapter();
+ }
+ @Override
+ public Adapter caseBoolLiteral(BoolLiteral object)
+ {
+ return createBoolLiteralAdapter();
+ }
+ @Override
+ public Adapter caseJSLiteral(JSLiteral object)
+ {
+ return createJSLiteralAdapter();
+ }
+ @Override
+ public Adapter caseRegexLiteral(RegexLiteral object)
+ {
+ return createRegexLiteralAdapter();
+ }
+ @Override
+ public Adapter caseLiteral(Literal object)
+ {
+ return createLiteralAdapter();
+ }
+ @Override
+ public Adapter caseParenthetical(Parenthetical object)
+ {
+ return createParentheticalAdapter();
+ }
+ @Override
+ public Adapter caseIf(If object)
+ {
+ return createIfAdapter();
+ }
+ @Override
+ public Adapter caseFor(For object)
+ {
+ return createForAdapter();
+ }
+ @Override
+ public Adapter caseWhile(While object)
+ {
+ return createWhileAdapter();
+ }
+ @Override
+ public Adapter caseUntil(Until object)
+ {
+ return createUntilAdapter();
+ }
+ @Override
+ public Adapter caseBinaryExp(BinaryExp object)
+ {
+ return createBinaryExpAdapter();
+ }
+ @Override
+ public Adapter caseSuperCall(SuperCall object)
+ {
+ return createSuperCallAdapter();
+ }
+ @Override
+ public Adapter caseThisAlone(ThisAlone object)
+ {
+ return createThisAloneAdapter();
+ }
+ @Override
+ public Adapter caseLoop(Loop object)
+ {
+ return createLoopAdapter();
+ }
+ @Override
+ public Adapter caseTryCatch(TryCatch object)
+ {
+ return createTryCatchAdapter();
+ }
+ @Override
+ public Adapter caseSwitch(Switch object)
+ {
+ return createSwitchAdapter();
+ }
+ @Override
+ public Adapter defaultCase(EObject object)
+ {
+ return createEObjectAdapter();
+ }
+ };
+
+ /**
+ * Creates an adapter for the target.
+ *
+ *
+ * @param target the object to adapt.
+ * @return the adapter for the target.
+ * @generated
+ */
+ @Override
+ public Adapter createAdapter(Notifier target)
+ {
+ return modelSwitch.doSwitch((EObject)target);
+ }
+
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Root Root }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Root
+ * @generated
+ */
+ public Adapter createRootAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Body Body }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Body
+ * @generated
+ */
+ public Adapter createBodyAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Line Line }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Line
+ * @generated
+ */
+ public Adapter createLineAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Stmt Stmt }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Stmt
+ * @generated
+ */
+ public Adapter createStmtAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Comment Comment }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Comment
+ * @generated
+ */
+ public Adapter createCommentAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.RequireStmt Require Stmt }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.RequireStmt
+ * @generated
+ */
+ public Adapter createRequireStmtAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ReturnStmt Return Stmt }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ReturnStmt
+ * @generated
+ */
+ public Adapter createReturnStmtAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ThrowStmt Throw Stmt }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ThrowStmt
+ * @generated
+ */
+ public Adapter createThrowStmtAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.SuperClass Super Class }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.SuperClass
+ * @generated
+ */
+ public Adapter createSuperClassAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ClassDeclaration Class Declaration }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ClassDeclaration
+ * @generated
+ */
+ public Adapter createClassDeclarationAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.AssignedClassDeclaration Assigned Class Declaration }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.AssignedClassDeclaration
+ * @generated
+ */
+ public Adapter createAssignedClassDeclarationAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Expression Expression }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Expression
+ * @generated
+ */
+ public Adapter createExpressionAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ForValue For Value }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ForValue
+ * @generated
+ */
+ public Adapter createForValueAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ForSource For Source }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ForSource
+ * @generated
+ */
+ public Adapter createForSourceAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Range Range }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Range
+ * @generated
+ */
+ public Adapter createRangeAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Application Application }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Application
+ * @generated
+ */
+ public Adapter createApplicationAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.FeatureCall Feature Call }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.FeatureCall
+ * @generated
+ */
+ public Adapter createFeatureCallAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.FunctionCall Function Call }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.FunctionCall
+ * @generated
+ */
+ public Adapter createFunctionCallAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.PropertyAccess Property Access }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.PropertyAccess
+ * @generated
+ */
+ public Adapter createPropertyAccessAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ThisProperty This Property }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ThisProperty
+ * @generated
+ */
+ public Adapter createThisPropertyAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.NamedPropertyAccess Named Property Access }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.NamedPropertyAccess
+ * @generated
+ */
+ public Adapter createNamedPropertyAccessAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.IndexedPropertyAccess Indexed Property Access }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.IndexedPropertyAccess
+ * @generated
+ */
+ public Adapter createIndexedPropertyAccessAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Index Index }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Index
+ * @generated
+ */
+ public Adapter createIndexAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.PrimaryExpression Primary Expression }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.PrimaryExpression
+ * @generated
+ */
+ public Adapter createPrimaryExpressionAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Block Block }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Block
+ * @generated
+ */
+ public Adapter createBlockAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Case Case }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Case
+ * @generated
+ */
+ public Adapter createCaseAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.IfExp If Exp }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.IfExp
+ * @generated
+ */
+ public Adapter createIfExpAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.CondBlock Cond Block }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.CondBlock
+ * @generated
+ */
+ public Adapter createCondBlockAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.IdRef Id Ref }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.IdRef
+ * @generated
+ */
+ public Adapter createIdRefAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Id Id }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Id
+ * @generated
+ */
+ public Adapter createIdAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Property Property }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Property
+ * @generated
+ */
+ public Adapter createPropertyAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Variable Variable }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Variable
+ * @generated
+ */
+ public Adapter createVariableAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.AssignableArray Assignable Array }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.AssignableArray
+ * @generated
+ */
+ public Adapter createAssignableArrayAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.AssignableArgList Assignable Arg List }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.AssignableArgList
+ * @generated
+ */
+ public Adapter createAssignableArgListAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.AssignableArg Assignable Arg }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.AssignableArg
+ * @generated
+ */
+ public Adapter createAssignableArgAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Assignable Assignable }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Assignable
+ * @generated
+ */
+ public Adapter createAssignableAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Arg Arg }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Arg
+ * @generated
+ */
+ public Adapter createArgAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ArgLine Arg Line }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ArgLine
+ * @generated
+ */
+ public Adapter createArgLineAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ExplicitArgList Explicit Arg List }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ExplicitArgList
+ * @generated
+ */
+ public Adapter createExplicitArgListAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ArgList Arg List }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ArgList
+ * @generated
+ */
+ public Adapter createArgListAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Array Array }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Array
+ * @generated
+ */
+ public Adapter createArrayAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Dictionary Dictionary }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Dictionary
+ * @generated
+ */
+ public Adapter createDictionaryAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.DictItems Dict Items }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.DictItems
+ * @generated
+ */
+ public Adapter createDictItemsAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ExplicitDictItems Explicit Dict Items }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ExplicitDictItems
+ * @generated
+ */
+ public Adapter createExplicitDictItemsAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.DictLine Dict Line }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.DictLine
+ * @generated
+ */
+ public Adapter createDictLineAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.DictItem Dict Item }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.DictItem
+ * @generated
+ */
+ public Adapter createDictItemAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.DictKey Dict Key }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.DictKey
+ * @generated
+ */
+ public Adapter createDictKeyAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Lambda Lambda }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Lambda
+ * @generated
+ */
+ public Adapter createLambdaAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Param Param }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Param
+ * @generated
+ */
+ public Adapter createParamAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.NumberLiteral Number Literal }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.NumberLiteral
+ * @generated
+ */
+ public Adapter createNumberLiteralAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.StringLiteral String Literal }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.StringLiteral
+ * @generated
+ */
+ public Adapter createStringLiteralAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.BoolLiteral Bool Literal }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.BoolLiteral
+ * @generated
+ */
+ public Adapter createBoolLiteralAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.JSLiteral JS Literal }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.JSLiteral
+ * @generated
+ */
+ public Adapter createJSLiteralAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.RegexLiteral Regex Literal }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.RegexLiteral
+ * @generated
+ */
+ public Adapter createRegexLiteralAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Literal Literal }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Literal
+ * @generated
+ */
+ public Adapter createLiteralAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Parenthetical Parenthetical }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Parenthetical
+ * @generated
+ */
+ public Adapter createParentheticalAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.If If }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.If
+ * @generated
+ */
+ public Adapter createIfAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.For For }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.For
+ * @generated
+ */
+ public Adapter createForAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.While While }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.While
+ * @generated
+ */
+ public Adapter createWhileAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Until Until }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Until
+ * @generated
+ */
+ public Adapter createUntilAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.BinaryExp Binary Exp }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.BinaryExp
+ * @generated
+ */
+ public Adapter createBinaryExpAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.SuperCall Super Call }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.SuperCall
+ * @generated
+ */
+ public Adapter createSuperCallAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.ThisAlone This Alone }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.ThisAlone
+ * @generated
+ */
+ public Adapter createThisAloneAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Loop Loop }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Loop
+ * @generated
+ */
+ public Adapter createLoopAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.TryCatch Try Catch }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.TryCatch
+ * @generated
+ */
+ public Adapter createTryCatchAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.coffeeScript.Switch Switch }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.coffeeScript.Switch
+ * @generated
+ */
+ public Adapter createSwitchAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for the default case.
+ *
+ * This default implementation returns null.
+ *
+ * @return the new adapter.
+ * @generated
+ */
+ public Adapter createEObjectAdapter()
+ {
+ return null;
+ }
+
+} //CoffeeScriptAdapterFactory
diff --git a/csep/src-gen/csep/coffeeScript/util/CoffeeScriptSwitch.java b/csep/src-gen/csep/coffeeScript/util/CoffeeScriptSwitch.java
new file mode 100644
index 0000000..c61a9f9
--- /dev/null
+++ b/csep/src-gen/csep/coffeeScript/util/CoffeeScriptSwitch.java
@@ -0,0 +1,1723 @@
+/**
+ */
+package csep.coffeeScript.util;
+
+import csep.coffeeScript.*;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+/**
+ *
+ * The Switch for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the caseXXX method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ *
+ * @see csep.coffeeScript.CoffeeScriptPackage
+ * @generated
+ */
+public class CoffeeScriptSwitch extends Switch
+{
+ /**
+ * The cached model package
+ *
+ *
+ * @generated
+ */
+ protected static CoffeeScriptPackage modelPackage;
+
+ /**
+ * Creates an instance of the switch.
+ *
+ *
+ * @generated
+ */
+ public CoffeeScriptSwitch()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = CoffeeScriptPackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Checks whether this is a switch for the given package.
+ *
+ *
+ * @parameter ePackage the package in question.
+ * @return whether this is a switch for the given package.
+ * @generated
+ */
+ @Override
+ protected boolean isSwitchFor(EPackage ePackage)
+ {
+ return ePackage == modelPackage;
+ }
+
+ /**
+ * Calls caseXXX for each class of the model until one returns a non null result; it yields that result.
+ *
+ *
+ * @return the first non-null result returned by a caseXXX call.
+ * @generated
+ */
+ @Override
+ protected T doSwitch(int classifierID, EObject theEObject)
+ {
+ switch (classifierID)
+ {
+ case CoffeeScriptPackage.ROOT:
+ {
+ Root root = (Root)theEObject;
+ T result = caseRoot(root);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.BODY:
+ {
+ Body body = (Body)theEObject;
+ T result = caseBody(body);
+ if (result == null) result = caseBlock(body);
+ if (result == null) result = caseRoot(body);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.LINE:
+ {
+ Line line = (Line)theEObject;
+ T result = caseLine(line);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.STMT:
+ {
+ Stmt stmt = (Stmt)theEObject;
+ T result = caseStmt(stmt);
+ if (result == null) result = caseLine(stmt);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.COMMENT:
+ {
+ Comment comment = (Comment)theEObject;
+ T result = caseComment(comment);
+ if (result == null) result = caseStmt(comment);
+ if (result == null) result = caseLine(comment);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.REQUIRE_STMT:
+ {
+ RequireStmt requireStmt = (RequireStmt)theEObject;
+ T result = caseRequireStmt(requireStmt);
+ if (result == null) result = caseStmt(requireStmt);
+ if (result == null) result = caseLine(requireStmt);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.RETURN_STMT:
+ {
+ ReturnStmt returnStmt = (ReturnStmt)theEObject;
+ T result = caseReturnStmt(returnStmt);
+ if (result == null) result = caseStmt(returnStmt);
+ if (result == null) result = caseLine(returnStmt);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.THROW_STMT:
+ {
+ ThrowStmt throwStmt = (ThrowStmt)theEObject;
+ T result = caseThrowStmt(throwStmt);
+ if (result == null) result = caseStmt(throwStmt);
+ if (result == null) result = caseLine(throwStmt);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.SUPER_CLASS:
+ {
+ SuperClass superClass = (SuperClass)theEObject;
+ T result = caseSuperClass(superClass);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.CLASS_DECLARATION:
+ {
+ ClassDeclaration classDeclaration = (ClassDeclaration)theEObject;
+ T result = caseClassDeclaration(classDeclaration);
+ if (result == null) result = caseStmt(classDeclaration);
+ if (result == null) result = caseAssignedClassDeclaration(classDeclaration);
+ if (result == null) result = caseExpression(classDeclaration);
+ if (result == null) result = caseLine(classDeclaration);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ASSIGNED_CLASS_DECLARATION:
+ {
+ AssignedClassDeclaration assignedClassDeclaration = (AssignedClassDeclaration)theEObject;
+ T result = caseAssignedClassDeclaration(assignedClassDeclaration);
+ if (result == null) result = caseExpression(assignedClassDeclaration);
+ if (result == null) result = caseLine(assignedClassDeclaration);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.EXPRESSION:
+ {
+ Expression expression = (Expression)theEObject;
+ T result = caseExpression(expression);
+ if (result == null) result = caseLine(expression);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.FOR_VALUE:
+ {
+ ForValue forValue = (ForValue)theEObject;
+ T result = caseForValue(forValue);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.FOR_SOURCE:
+ {
+ ForSource forSource = (ForSource)theEObject;
+ T result = caseForSource(forSource);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.RANGE:
+ {
+ Range range = (Range)theEObject;
+ T result = caseRange(range);
+ if (result == null) result = casePrimaryExpression(range);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.APPLICATION:
+ {
+ Application application = (Application)theEObject;
+ T result = caseApplication(application);
+ if (result == null) result = caseExpression(application);
+ if (result == null) result = caseLine(application);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.FEATURE_CALL:
+ {
+ FeatureCall featureCall = (FeatureCall)theEObject;
+ T result = caseFeatureCall(featureCall);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.FUNCTION_CALL:
+ {
+ FunctionCall functionCall = (FunctionCall)theEObject;
+ T result = caseFunctionCall(functionCall);
+ if (result == null) result = caseFeatureCall(functionCall);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.PROPERTY_ACCESS:
+ {
+ PropertyAccess propertyAccess = (PropertyAccess)theEObject;
+ T result = casePropertyAccess(propertyAccess);
+ if (result == null) result = caseFeatureCall(propertyAccess);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.THIS_PROPERTY:
+ {
+ ThisProperty thisProperty = (ThisProperty)theEObject;
+ T result = caseThisProperty(thisProperty);
+ if (result == null) result = casePrimaryExpression(thisProperty);
+ if (result == null) result = caseParam(thisProperty);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.NAMED_PROPERTY_ACCESS:
+ {
+ NamedPropertyAccess namedPropertyAccess = (NamedPropertyAccess)theEObject;
+ T result = caseNamedPropertyAccess(namedPropertyAccess);
+ if (result == null) result = casePropertyAccess(namedPropertyAccess);
+ if (result == null) result = caseFeatureCall(namedPropertyAccess);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.INDEXED_PROPERTY_ACCESS:
+ {
+ IndexedPropertyAccess indexedPropertyAccess = (IndexedPropertyAccess)theEObject;
+ T result = caseIndexedPropertyAccess(indexedPropertyAccess);
+ if (result == null) result = casePropertyAccess(indexedPropertyAccess);
+ if (result == null) result = caseFeatureCall(indexedPropertyAccess);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.INDEX:
+ {
+ Index index = (Index)theEObject;
+ T result = caseIndex(index);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.PRIMARY_EXPRESSION:
+ {
+ PrimaryExpression primaryExpression = (PrimaryExpression)theEObject;
+ T result = casePrimaryExpression(primaryExpression);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.BLOCK:
+ {
+ Block block = (Block)theEObject;
+ T result = caseBlock(block);
+ if (result == null) result = caseRoot(block);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.CASE:
+ {
+ Case case_ = (Case)theEObject;
+ T result = caseCase(case_);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.IF_EXP:
+ {
+ IfExp ifExp = (IfExp)theEObject;
+ T result = caseIfExp(ifExp);
+ if (result == null) result = casePrimaryExpression(ifExp);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.COND_BLOCK:
+ {
+ CondBlock condBlock = (CondBlock)theEObject;
+ T result = caseCondBlock(condBlock);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ID_REF:
+ {
+ IdRef idRef = (IdRef)theEObject;
+ T result = caseIdRef(idRef);
+ if (result == null) result = casePrimaryExpression(idRef);
+ if (result == null) result = caseProperty(idRef);
+ if (result == null) result = caseSuperClass(idRef);
+ if (result == null) result = caseVariable(idRef);
+ if (result == null) result = caseExpression(idRef);
+ if (result == null) result = caseAssignable(idRef);
+ if (result == null) result = caseLine(idRef);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ID:
+ {
+ Id id = (Id)theEObject;
+ T result = caseId(id);
+ if (result == null) result = caseForValue(id);
+ if (result == null) result = caseThisProperty(id);
+ if (result == null) result = caseVariable(id);
+ if (result == null) result = caseDictKey(id);
+ if (result == null) result = casePrimaryExpression(id);
+ if (result == null) result = caseParam(id);
+ if (result == null) result = caseExpression(id);
+ if (result == null) result = caseAssignable(id);
+ if (result == null) result = caseLine(id);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.PROPERTY:
+ {
+ Property property = (Property)theEObject;
+ T result = caseProperty(property);
+ if (result == null) result = caseSuperClass(property);
+ if (result == null) result = caseVariable(property);
+ if (result == null) result = caseExpression(property);
+ if (result == null) result = caseAssignable(property);
+ if (result == null) result = caseLine(property);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.VARIABLE:
+ {
+ Variable variable = (Variable)theEObject;
+ T result = caseVariable(variable);
+ if (result == null) result = caseExpression(variable);
+ if (result == null) result = caseAssignable(variable);
+ if (result == null) result = caseLine(variable);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ASSIGNABLE_ARRAY:
+ {
+ AssignableArray assignableArray = (AssignableArray)theEObject;
+ T result = caseAssignableArray(assignableArray);
+ if (result == null) result = caseAssignable(assignableArray);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ASSIGNABLE_ARG_LIST:
+ {
+ AssignableArgList assignableArgList = (AssignableArgList)theEObject;
+ T result = caseAssignableArgList(assignableArgList);
+ if (result == null) result = caseAssignableArray(assignableArgList);
+ if (result == null) result = caseAssignable(assignableArgList);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ASSIGNABLE_ARG:
+ {
+ AssignableArg assignableArg = (AssignableArg)theEObject;
+ T result = caseAssignableArg(assignableArg);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ASSIGNABLE:
+ {
+ Assignable assignable = (Assignable)theEObject;
+ T result = caseAssignable(assignable);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ARG:
+ {
+ Arg arg = (Arg)theEObject;
+ T result = caseArg(arg);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ARG_LINE:
+ {
+ ArgLine argLine = (ArgLine)theEObject;
+ T result = caseArgLine(argLine);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.EXPLICIT_ARG_LIST:
+ {
+ ExplicitArgList explicitArgList = (ExplicitArgList)theEObject;
+ T result = caseExplicitArgList(explicitArgList);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ARG_LIST:
+ {
+ ArgList argList = (ArgList)theEObject;
+ T result = caseArgList(argList);
+ if (result == null) result = caseArray(argList);
+ if (result == null) result = casePrimaryExpression(argList);
+ if (result == null) result = caseParam(argList);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.ARRAY:
+ {
+ Array array = (Array)theEObject;
+ T result = caseArray(array);
+ if (result == null) result = casePrimaryExpression(array);
+ if (result == null) result = caseParam(array);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.DICTIONARY:
+ {
+ Dictionary dictionary = (Dictionary)theEObject;
+ T result = caseDictionary(dictionary);
+ if (result == null) result = casePrimaryExpression(dictionary);
+ if (result == null) result = caseAssignable(dictionary);
+ if (result == null) result = caseParam(dictionary);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.DICT_ITEMS:
+ {
+ DictItems dictItems = (DictItems)theEObject;
+ T result = caseDictItems(dictItems);
+ if (result == null) result = caseDictionary(dictItems);
+ if (result == null) result = casePrimaryExpression(dictItems);
+ if (result == null) result = caseAssignable(dictItems);
+ if (result == null) result = caseParam(dictItems);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.EXPLICIT_DICT_ITEMS:
+ {
+ ExplicitDictItems explicitDictItems = (ExplicitDictItems)theEObject;
+ T result = caseExplicitDictItems(explicitDictItems);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.DICT_LINE:
+ {
+ DictLine dictLine = (DictLine)theEObject;
+ T result = caseDictLine(dictLine);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.DICT_ITEM:
+ {
+ DictItem dictItem = (DictItem)theEObject;
+ T result = caseDictItem(dictItem);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.DICT_KEY:
+ {
+ DictKey dictKey = (DictKey)theEObject;
+ T result = caseDictKey(dictKey);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.LAMBDA:
+ {
+ Lambda lambda = (Lambda)theEObject;
+ T result = caseLambda(lambda);
+ if (result == null) result = casePrimaryExpression(lambda);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.PARAM:
+ {
+ Param param = (Param)theEObject;
+ T result = caseParam(param);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.NUMBER_LITERAL:
+ {
+ NumberLiteral numberLiteral = (NumberLiteral)theEObject;
+ T result = caseNumberLiteral(numberLiteral);
+ if (result == null) result = caseLiteral(numberLiteral);
+ if (result == null) result = casePrimaryExpression(numberLiteral);
+ if (result == null) result = caseDictKey(numberLiteral);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.STRING_LITERAL:
+ {
+ StringLiteral stringLiteral = (StringLiteral)theEObject;
+ T result = caseStringLiteral(stringLiteral);
+ if (result == null) result = caseLiteral(stringLiteral);
+ if (result == null) result = casePrimaryExpression(stringLiteral);
+ if (result == null) result = caseDictKey(stringLiteral);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.BOOL_LITERAL:
+ {
+ BoolLiteral boolLiteral = (BoolLiteral)theEObject;
+ T result = caseBoolLiteral(boolLiteral);
+ if (result == null) result = caseLiteral(boolLiteral);
+ if (result == null) result = casePrimaryExpression(boolLiteral);
+ if (result == null) result = caseDictKey(boolLiteral);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.JS_LITERAL:
+ {
+ JSLiteral jsLiteral = (JSLiteral)theEObject;
+ T result = caseJSLiteral(jsLiteral);
+ if (result == null) result = caseLiteral(jsLiteral);
+ if (result == null) result = casePrimaryExpression(jsLiteral);
+ if (result == null) result = caseDictKey(jsLiteral);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.REGEX_LITERAL:
+ {
+ RegexLiteral regexLiteral = (RegexLiteral)theEObject;
+ T result = caseRegexLiteral(regexLiteral);
+ if (result == null) result = caseLiteral(regexLiteral);
+ if (result == null) result = casePrimaryExpression(regexLiteral);
+ if (result == null) result = caseDictKey(regexLiteral);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.LITERAL:
+ {
+ Literal literal = (Literal)theEObject;
+ T result = caseLiteral(literal);
+ if (result == null) result = casePrimaryExpression(literal);
+ if (result == null) result = caseDictKey(literal);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.PARENTHETICAL:
+ {
+ Parenthetical parenthetical = (Parenthetical)theEObject;
+ T result = caseParenthetical(parenthetical);
+ if (result == null) result = casePrimaryExpression(parenthetical);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.IF:
+ {
+ If if_ = (If)theEObject;
+ T result = caseIf(if_);
+ if (result == null) result = caseExpression(if_);
+ if (result == null) result = caseLine(if_);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.FOR:
+ {
+ For for_ = (For)theEObject;
+ T result = caseFor(for_);
+ if (result == null) result = caseExpression(for_);
+ if (result == null) result = casePrimaryExpression(for_);
+ if (result == null) result = caseLine(for_);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.WHILE:
+ {
+ While while_ = (While)theEObject;
+ T result = caseWhile(while_);
+ if (result == null) result = caseExpression(while_);
+ if (result == null) result = casePrimaryExpression(while_);
+ if (result == null) result = caseLine(while_);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.UNTIL:
+ {
+ Until until = (Until)theEObject;
+ T result = caseUntil(until);
+ if (result == null) result = caseExpression(until);
+ if (result == null) result = casePrimaryExpression(until);
+ if (result == null) result = caseLine(until);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.BINARY_EXP:
+ {
+ BinaryExp binaryExp = (BinaryExp)theEObject;
+ T result = caseBinaryExp(binaryExp);
+ if (result == null) result = caseExpression(binaryExp);
+ if (result == null) result = caseLine(binaryExp);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.SUPER_CALL:
+ {
+ SuperCall superCall = (SuperCall)theEObject;
+ T result = caseSuperCall(superCall);
+ if (result == null) result = caseApplication(superCall);
+ if (result == null) result = caseExpression(superCall);
+ if (result == null) result = caseLine(superCall);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.THIS_ALONE:
+ {
+ ThisAlone thisAlone = (ThisAlone)theEObject;
+ T result = caseThisAlone(thisAlone);
+ if (result == null) result = casePrimaryExpression(thisAlone);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.LOOP:
+ {
+ Loop loop = (Loop)theEObject;
+ T result = caseLoop(loop);
+ if (result == null) result = casePrimaryExpression(loop);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.TRY_CATCH:
+ {
+ TryCatch tryCatch = (TryCatch)theEObject;
+ T result = caseTryCatch(tryCatch);
+ if (result == null) result = casePrimaryExpression(tryCatch);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CoffeeScriptPackage.SWITCH:
+ {
+ csep.coffeeScript.Switch switch_ = (csep.coffeeScript.Switch)theEObject;
+ T result = caseSwitch(switch_);
+ if (result == null) result = casePrimaryExpression(switch_);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ default: return defaultCase(theEObject);
+ }
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Root '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Root '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseRoot(Root object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Body '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Body '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseBody(Body object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Line '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Line '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseLine(Line object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Stmt '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Stmt '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseStmt(Stmt object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Comment '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Comment '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseComment(Comment object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Require Stmt '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Require Stmt '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseRequireStmt(RequireStmt object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Return Stmt '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Return Stmt '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseReturnStmt(ReturnStmt object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Throw Stmt '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Throw Stmt '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseThrowStmt(ThrowStmt object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Super Class '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Super Class '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseSuperClass(SuperClass object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Class Declaration '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Class Declaration '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseClassDeclaration(ClassDeclaration object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Assigned Class Declaration '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Assigned Class Declaration '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseAssignedClassDeclaration(AssignedClassDeclaration object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Expression '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Expression '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseExpression(Expression object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'For Value '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'For Value '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseForValue(ForValue object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'For Source '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'For Source '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseForSource(ForSource object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Range '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Range '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseRange(Range object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Application '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Application '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseApplication(Application object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Feature Call '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Feature Call '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseFeatureCall(FeatureCall object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Function Call '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Function Call '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseFunctionCall(FunctionCall object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Property Access '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Property Access '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T casePropertyAccess(PropertyAccess object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'This Property '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'This Property '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseThisProperty(ThisProperty object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Named Property Access '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Named Property Access '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseNamedPropertyAccess(NamedPropertyAccess object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Indexed Property Access '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Indexed Property Access '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseIndexedPropertyAccess(IndexedPropertyAccess object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Index '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Index '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseIndex(Index object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Primary Expression '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Primary Expression '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T casePrimaryExpression(PrimaryExpression object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Block '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Block '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseBlock(Block object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Case '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Case '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseCase(Case object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'If Exp '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'If Exp '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseIfExp(IfExp object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Cond Block '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Cond Block '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseCondBlock(CondBlock object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Id Ref '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Id Ref '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseIdRef(IdRef object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Id '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Id '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseId(Id object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Property '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Property '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseProperty(Property object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Variable '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Variable '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseVariable(Variable object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Assignable Array '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Assignable Array '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseAssignableArray(AssignableArray object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Assignable Arg List '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Assignable Arg List '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseAssignableArgList(AssignableArgList object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Assignable Arg '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Assignable Arg '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseAssignableArg(AssignableArg object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Assignable '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Assignable '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseAssignable(Assignable object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Arg '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Arg '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseArg(Arg object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Arg Line '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Arg Line '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseArgLine(ArgLine object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Explicit Arg List '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Explicit Arg List '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseExplicitArgList(ExplicitArgList object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Arg List '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Arg List '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseArgList(ArgList object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Array '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Array '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseArray(Array object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Dictionary '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Dictionary '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseDictionary(Dictionary object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Dict Items '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Dict Items '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseDictItems(DictItems object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Explicit Dict Items '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Explicit Dict Items '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseExplicitDictItems(ExplicitDictItems object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Dict Line '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Dict Line '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseDictLine(DictLine object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Dict Item '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Dict Item '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseDictItem(DictItem object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Dict Key '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Dict Key '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseDictKey(DictKey object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Lambda '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Lambda '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseLambda(Lambda object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Param '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Param '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseParam(Param object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Number Literal '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Number Literal '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseNumberLiteral(NumberLiteral object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'String Literal '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'String Literal '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseStringLiteral(StringLiteral object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Bool Literal '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Bool Literal '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseBoolLiteral(BoolLiteral object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'JS Literal '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'JS Literal '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseJSLiteral(JSLiteral object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Regex Literal '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Regex Literal '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseRegexLiteral(RegexLiteral object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Literal '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Literal '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseLiteral(Literal object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Parenthetical '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Parenthetical '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseParenthetical(Parenthetical object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'If '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'If '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseIf(If object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'For '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'For '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseFor(For object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'While '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'While '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseWhile(While object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Until '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Until '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseUntil(Until object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Binary Exp '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Binary Exp '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseBinaryExp(BinaryExp object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Super Call '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Super Call '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseSuperCall(SuperCall object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'This Alone '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'This Alone '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseThisAlone(ThisAlone object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Loop '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Loop '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseLoop(Loop object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Try Catch '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Try Catch '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseTryCatch(TryCatch object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Switch '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Switch '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseSwitch(csep.coffeeScript.Switch object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'EObject '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch, but this is the last case anyway.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'EObject '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+ * @generated
+ */
+ @Override
+ public T defaultCase(EObject object)
+ {
+ return null;
+ }
+
+} //CoffeeScriptSwitch
diff --git a/csep/src-gen/csep/parseTreeConstruction/CoffeeScriptParsetreeConstructor.java b/csep/src-gen/csep/parseTreeConstruction/CoffeeScriptParsetreeConstructor.java
new file mode 100644
index 0000000..9209634
--- /dev/null
+++ b/csep/src-gen/csep/parseTreeConstruction/CoffeeScriptParsetreeConstructor.java
@@ -0,0 +1,17411 @@
+/*
+* generated by Xtext
+*/
+package csep.parseTreeConstruction;
+
+import org.eclipse.emf.ecore.*;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parsetree.reconstr.IEObjectConsumer;
+
+import csep.services.CoffeeScriptGrammarAccess;
+
+import com.google.inject.Inject;
+
+@SuppressWarnings("all")
+public class CoffeeScriptParsetreeConstructor extends org.eclipse.xtext.parsetree.reconstr.impl.AbstractParseTreeConstructor {
+
+ @Inject
+ private CoffeeScriptGrammarAccess grammarAccess;
+
+ @Override
+ protected AbstractToken getRootToken(IEObjectConsumer inst) {
+ return new ThisRootNode(inst);
+ }
+
+protected class ThisRootNode extends RootToken {
+ public ThisRootNode(IEObjectConsumer inst) {
+ super(inst);
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Root_Alternatives(this, this, 0, inst);
+ case 1: return new Body_Group(this, this, 1, inst);
+ case 2: return new Line_Alternatives(this, this, 2, inst);
+ case 3: return new Stmt_Alternatives(this, this, 3, inst);
+ case 4: return new Comment_CommentAssignment(this, this, 4, inst);
+ case 5: return new RequireStmt_Group(this, this, 5, inst);
+ case 6: return new ReturnStmt_Group(this, this, 6, inst);
+ case 7: return new ThrowStmt_Group(this, this, 7, inst);
+ case 8: return new SuperClass_Alternatives(this, this, 8, inst);
+ case 9: return new ClassDeclaration_Group(this, this, 9, inst);
+ case 10: return new AssignedClassDeclaration_Group(this, this, 10, inst);
+ case 11: return new Expression_PostfixParserRuleCall(this, this, 11, inst);
+ case 12: return new Postfix_Group(this, this, 12, inst);
+ case 13: return new ForBody_Group(this, this, 13, inst);
+ case 14: return new ForValue_IdParserRuleCall(this, this, 14, inst);
+ case 15: return new ForSource_Group(this, this, 15, inst);
+ case 16: return new Range_Group(this, this, 16, inst);
+ case 17: return new Assignment_Alternatives(this, this, 17, inst);
+ case 18: return new Assigned_Alternatives(this, this, 18, inst);
+ case 19: return new LogicOp_Group(this, this, 19, inst);
+ case 20: return new CompareOp_Group(this, this, 20, inst);
+ case 21: return new RelationOp_Group(this, this, 21, inst);
+ case 22: return new ShiftOp_Group(this, this, 22, inst);
+ case 23: return new AdditiveOp_Group(this, this, 23, inst);
+ case 24: return new MathOp_Group(this, this, 24, inst);
+ case 25: return new UnaryOp_Alternatives(this, this, 25, inst);
+ case 26: return new Application_Alternatives(this, this, 26, inst);
+ case 27: return new FeatureCall_Alternatives(this, this, 27, inst);
+ case 28: return new FunctionCall_Group(this, this, 28, inst);
+ case 29: return new PropertyAccess_Alternatives(this, this, 29, inst);
+ case 30: return new ThisProperty_Group(this, this, 30, inst);
+ case 31: return new NamedPropertyAccess_Alternatives(this, this, 31, inst);
+ case 32: return new IndexedPropertyAccess_Group(this, this, 32, inst);
+ case 33: return new Index_Alternatives(this, this, 33, inst);
+ case 34: return new PrimaryExpression_Alternatives(this, this, 34, inst);
+ case 35: return new Block_Group(this, this, 35, inst);
+ case 36: return new Case_Group(this, this, 36, inst);
+ case 37: return new IfExp_Group(this, this, 37, inst);
+ case 38: return new CondBlock_Group(this, this, 38, inst);
+ case 39: return new IdRef_ValAssignment(this, this, 39, inst);
+ case 40: return new Id_NameAssignment(this, this, 40, inst);
+ case 41: return new Property_Alternatives(this, this, 41, inst);
+ case 42: return new Variable_Alternatives(this, this, 42, inst);
+ case 43: return new AssignableArray_Group(this, this, 43, inst);
+ case 44: return new AssignableArgList_Group(this, this, 44, inst);
+ case 45: return new AssignableArg_Group(this, this, 45, inst);
+ case 46: return new Assignable_Alternatives(this, this, 46, inst);
+ case 47: return new Arg_Group(this, this, 47, inst);
+ case 48: return new ArgLine_Group(this, this, 48, inst);
+ case 49: return new ExplicitArgList_Group(this, this, 49, inst);
+ case 50: return new ArgList_Group(this, this, 50, inst);
+ case 51: return new Array_Group(this, this, 51, inst);
+ case 52: return new Dictionary_Group(this, this, 52, inst);
+ case 53: return new DictItems_Group(this, this, 53, inst);
+ case 54: return new ExplicitDictItems_Group(this, this, 54, inst);
+ case 55: return new DictLine_Group(this, this, 55, inst);
+ case 56: return new DictItem_Group(this, this, 56, inst);
+ case 57: return new DictKey_Alternatives(this, this, 57, inst);
+ case 58: return new Lambda_Group(this, this, 58, inst);
+ case 59: return new Param_Group(this, this, 59, inst);
+ case 60: return new NumberLiteral_Group(this, this, 60, inst);
+ case 61: return new StringLiteral_Group(this, this, 61, inst);
+ case 62: return new BoolLiteral_Group(this, this, 62, inst);
+ case 63: return new JSLiteral_Group(this, this, 63, inst);
+ case 64: return new RegexLiteral_Group(this, this, 64, inst);
+ case 65: return new Literal_Alternatives(this, this, 65, inst);
+ case 66: return new Parenthetical_Alternatives(this, this, 66, inst);
+ default: return null;
+ }
+ }
+}
+
+
+/************ begin Rule Root ****************
+ *
+ * Root:
+ * (Body | Block TERMINATOR)?;
+ *
+ **/
+
+// (Body | Block TERMINATOR)?
+protected class Root_Alternatives extends AlternativesToken {
+
+ public Root_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getRootAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Root_BodyParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Root_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBlockAccess().getBlockAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getBodyRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Body
+protected class Root_BodyParserRuleCall_0 extends RuleCallToken {
+
+ public Root_BodyParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRootAccess().getBodyParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBodyRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Body_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Block TERMINATOR
+protected class Root_Group_1 extends GroupToken {
+
+ public Root_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRootAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Root_TERMINATORTerminalRuleCall_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// Block
+protected class Root_BlockParserRuleCall_1_0 extends RuleCallToken {
+
+ public Root_BlockParserRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRootAccess().getBlockParserRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Block_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// TERMINATOR
+protected class Root_TERMINATORTerminalRuleCall_1_1 extends UnassignedTextToken {
+
+ public Root_TERMINATORTerminalRuleCall_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRootAccess().getTERMINATORTerminalRuleCall_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Root_BlockParserRuleCall_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+/************ end Rule Root ****************/
+
+
+/************ begin Rule Body ****************
+ *
+ * Body:
+ * lines+=Line (TERMINATOR lines+=Line?)*;
+ *
+ **/
+
+// lines+=Line (TERMINATOR lines+=Line?)*
+protected class Body_Group extends GroupToken {
+
+ public Body_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getBodyAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Body_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBodyRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// lines+=Line
+protected class Body_LinesAssignment_0 extends AssignmentToken {
+
+ public Body_LinesAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getBodyAccess().getLinesAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Line_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (TERMINATOR lines+=Line?)*
+protected class Body_Group_1 extends GroupToken {
+
+ public Body_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getBodyAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_LinesAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR
+protected class Body_TERMINATORTerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public Body_TERMINATORTerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Body_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=Line?
+protected class Body_LinesAssignment_1_1 extends AssignmentToken {
+
+ public Body_LinesAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getBodyAccess().getLinesAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Line_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Body_TERMINATORTerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule Body ****************/
+
+
+/************ begin Rule Line ****************
+ *
+ * Line:
+ * Stmt | Expression;
+ *
+ **/
+
+// Stmt | Expression
+protected class Line_Alternatives extends AlternativesToken {
+
+ public Line_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getLineAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Line_StmtParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Line_ExpressionParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Stmt
+protected class Line_StmtParserRuleCall_0 extends RuleCallToken {
+
+ public Line_StmtParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLineAccess().getStmtParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Stmt_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Stmt_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Expression
+protected class Line_ExpressionParserRuleCall_1 extends RuleCallToken {
+
+ public Line_ExpressionParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLineAccess().getExpressionParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Expression_PostfixParserRuleCall.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Line ****************/
+
+
+/************ begin Rule Stmt ****************
+ *
+ * Stmt:
+ * ReturnStmt | ThrowStmt | RequireStmt | Comment | ClassDeclaration | statement=STATEMENT;
+ *
+ **/
+
+// ReturnStmt | ThrowStmt | RequireStmt | Comment | ClassDeclaration | statement=STATEMENT
+protected class Stmt_Alternatives extends AlternativesToken {
+
+ public Stmt_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getStmtAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Stmt_ReturnStmtParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Stmt_ThrowStmtParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Stmt_RequireStmtParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new Stmt_CommentParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
+ case 4: return new Stmt_ClassDeclarationParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
+ case 5: return new Stmt_StatementAssignment_5(lastRuleCallOrigin, this, 5, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// ReturnStmt
+protected class Stmt_ReturnStmtParserRuleCall_0 extends RuleCallToken {
+
+ public Stmt_ReturnStmtParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ReturnStmt_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// ThrowStmt
+protected class Stmt_ThrowStmtParserRuleCall_1 extends RuleCallToken {
+
+ public Stmt_ThrowStmtParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThrowStmt_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ThrowStmt_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// RequireStmt
+protected class Stmt_RequireStmtParserRuleCall_2 extends RuleCallToken {
+
+ public Stmt_RequireStmtParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(RequireStmt_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Comment
+protected class Stmt_CommentParserRuleCall_3 extends RuleCallToken {
+
+ public Stmt_CommentParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getCommentParserRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Comment_CommentAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Comment_CommentAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// ClassDeclaration
+protected class Stmt_ClassDeclarationParserRuleCall_4 extends RuleCallToken {
+
+ public Stmt_ClassDeclarationParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ClassDeclaration_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// statement=STATEMENT
+protected class Stmt_StatementAssignment_5 extends AssignmentToken {
+
+ public Stmt_StatementAssignment_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getStmtAccess().getStatementAssignment_5();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getStmtRule().getType().getClassifier())
+ return null;
+ if((value = eObjectConsumer.getConsumable("statement",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("statement");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+/************ end Rule Stmt ****************/
+
+
+/************ begin Rule Comment ****************
+ *
+ * Comment:
+ * comment=HERECOMMENT;
+ *
+ **/
+
+// comment=HERECOMMENT
+protected class Comment_CommentAssignment extends AssignmentToken {
+
+ public Comment_CommentAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCommentAccess().getCommentAssignment();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier())
+ return null;
+ if((value = eObjectConsumer.getConsumable("comment",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("comment");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+/************ end Rule Comment ****************/
+
+
+/************ begin Rule RequireStmt ****************
+ *
+ * / **
+ * * Treat it a special way, because it takes care of import
+ * * / RequireStmt:
+ * => (importedNamespace=Id EQUAL "require") CALL_START uri=STRING CALL_END;
+ *
+ **/
+
+// => (importedNamespace=Id EQUAL "require") CALL_START uri=STRING CALL_END
+protected class RequireStmt_Group extends GroupToken {
+
+ public RequireStmt_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_CALL_ENDTerminalRuleCall_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (importedNamespace=Id EQUAL "require")
+protected class RequireStmt_Group_0 extends GroupToken {
+
+ public RequireStmt_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_Group_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// importedNamespace=Id EQUAL "require"
+protected class RequireStmt_Group_0_0 extends GroupToken {
+
+ public RequireStmt_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_RequireKeyword_0_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// importedNamespace=Id
+protected class RequireStmt_ImportedNamespaceAssignment_0_0_0 extends AssignmentToken {
+
+ public RequireStmt_ImportedNamespaceAssignment_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getImportedNamespaceAssignment_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("importedNamespace",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("importedNamespace");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// EQUAL
+protected class RequireStmt_EQUALTerminalRuleCall_0_0_1 extends UnassignedTextToken {
+
+ public RequireStmt_EQUALTerminalRuleCall_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_ImportedNamespaceAssignment_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// "require"
+protected class RequireStmt_RequireKeyword_0_0_2 extends KeywordToken {
+
+ public RequireStmt_RequireKeyword_0_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Keyword getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_EQUALTerminalRuleCall_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+// CALL_START
+protected class RequireStmt_CALL_STARTTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public RequireStmt_CALL_STARTTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_Group_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// uri=STRING
+protected class RequireStmt_UriAssignment_2 extends AssignmentToken {
+
+ public RequireStmt_UriAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getUriAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_CALL_STARTTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("uri",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("uri");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// CALL_END
+protected class RequireStmt_CALL_ENDTerminalRuleCall_3 extends UnassignedTextToken {
+
+ public RequireStmt_CALL_ENDTerminalRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_UriAssignment_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule RequireStmt ****************/
+
+
+/************ begin Rule ReturnStmt ****************
+ *
+ * ReturnStmt:
+ * {ReturnStmt} RETURN expression=Expression? (POST_IF condition=Expression)?;
+ *
+ **/
+
+// {ReturnStmt} RETURN expression=Expression? (POST_IF condition=Expression)?
+protected class ReturnStmt_Group extends GroupToken {
+
+ public ReturnStmt_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_Group_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ReturnStmt_ExpressionAssignment_2(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new ReturnStmt_RETURNTerminalRuleCall_1(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ReturnStmt}
+protected class ReturnStmt_ReturnStmtAction_0 extends ActionToken {
+
+ public ReturnStmt_ReturnStmtAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getReturnStmtAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// RETURN
+protected class ReturnStmt_RETURNTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public ReturnStmt_RETURNTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_ReturnStmtAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// expression=Expression?
+protected class ReturnStmt_ExpressionAssignment_2 extends AssignmentToken {
+
+ public ReturnStmt_ExpressionAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getExpressionAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("expression",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("expression");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ReturnStmt_RETURNTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (POST_IF condition=Expression)?
+protected class ReturnStmt_Group_3 extends GroupToken {
+
+ public ReturnStmt_Group_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getGroup_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_ConditionAssignment_3_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// POST_IF
+protected class ReturnStmt_POST_IFTerminalRuleCall_3_0 extends UnassignedTextToken {
+
+ public ReturnStmt_POST_IFTerminalRuleCall_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_ExpressionAssignment_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ReturnStmt_RETURNTerminalRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// condition=Expression
+protected class ReturnStmt_ConditionAssignment_3_1 extends AssignmentToken {
+
+ public ReturnStmt_ConditionAssignment_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getConditionAssignment_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("condition",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("condition");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ReturnStmt_POST_IFTerminalRuleCall_3_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule ReturnStmt ****************/
+
+
+/************ begin Rule ThrowStmt ****************
+ *
+ * ThrowStmt:
+ * THROW exp=Expression;
+ *
+ **/
+
+// THROW exp=Expression
+protected class ThrowStmt_Group extends GroupToken {
+
+ public ThrowStmt_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getThrowStmtAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThrowStmt_ExpAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// THROW
+protected class ThrowStmt_THROWTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public ThrowStmt_THROWTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// exp=Expression
+protected class ThrowStmt_ExpAssignment_1 extends AssignmentToken {
+
+ public ThrowStmt_ExpAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getThrowStmtAccess().getExpAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exp",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exp");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ThrowStmt_THROWTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule ThrowStmt ****************/
+
+
+/************ begin Rule SuperClass ****************
+ *
+ * / **
+ * * Coffeescript is permissive, it can be any expression, but we want to be able to check it as crossref
+ * * / SuperClass:
+ * IdRef | Property;
+ *
+ **/
+
+// IdRef | Property
+protected class SuperClass_Alternatives extends AlternativesToken {
+
+ public SuperClass_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getSuperClassAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_IdRefParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new SuperClass_PropertyParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// IdRef
+protected class SuperClass_IdRefParserRuleCall_0 extends RuleCallToken {
+
+ public SuperClass_IdRefParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IdRef_ValAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(IdRef_ValAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Property
+protected class SuperClass_PropertyParserRuleCall_1 extends RuleCallToken {
+
+ public SuperClass_PropertyParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Property_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule SuperClass ****************/
+
+
+/************ begin Rule ClassDeclaration ****************
+ *
+ * ClassDeclaration:
+ * {ClassDeclaration} CLASS (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS
+ * extend=SuperClass)? body=Block)?;
+ *
+ **/
+
+// {ClassDeclaration} CLASS (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS
+// extend=SuperClass)? body=Block)?
+protected class ClassDeclaration_Group extends GroupToken {
+
+ public ClassDeclaration_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_Alternatives_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ClassDeclaration}
+protected class ClassDeclaration_ClassDeclarationAction_0 extends ActionToken {
+
+ public ClassDeclaration_ClassDeclarationAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// CLASS
+protected class ClassDeclaration_CLASSTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public ClassDeclaration_CLASSTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_ClassDeclarationAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block)?
+protected class ClassDeclaration_Alternatives_2 extends AlternativesToken {
+
+ public ClassDeclaration_Alternatives_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getAlternatives_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_BodyAssignment_2_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ClassDeclaration_Group_2_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new ClassDeclaration_Group_2_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// body=Block
+protected class ClassDeclaration_BodyAssignment_2_0 extends AssignmentToken {
+
+ public ClassDeclaration_BodyAssignment_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// EXTENDS extend=SuperClass body=Block?
+protected class ClassDeclaration_Group_2_1 extends GroupToken {
+
+ public ClassDeclaration_Group_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getGroup_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_BodyAssignment_2_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ClassDeclaration_ExtendAssignment_2_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS
+protected class ClassDeclaration_EXTENDSTerminalRuleCall_2_1_0 extends UnassignedTextToken {
+
+ public ClassDeclaration_EXTENDSTerminalRuleCall_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// extend=SuperClass
+protected class ClassDeclaration_ExtendAssignment_2_1_1 extends AssignmentToken {
+
+ public ClassDeclaration_ExtendAssignment_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("extend",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("extend");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getSuperClassRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_EXTENDSTerminalRuleCall_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// body=Block?
+protected class ClassDeclaration_BodyAssignment_2_1_2 extends AssignmentToken {
+
+ public ClassDeclaration_BodyAssignment_2_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_ExtendAssignment_2_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block
+protected class ClassDeclaration_Group_2_2 extends GroupToken {
+
+ public ClassDeclaration_Group_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getGroup_2_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_BodyAssignment_2_2_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// name=(Id | Property)
+protected class ClassDeclaration_NameAssignment_2_2_0 extends AssignmentToken {
+
+ public ClassDeclaration_NameAssignment_2_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getNameAssignment_2_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ case 1: return new Property_Alternatives(this, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getPropertyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (EXTENDS extend=SuperClass)?
+protected class ClassDeclaration_Group_2_2_1 extends GroupToken {
+
+ public ClassDeclaration_Group_2_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getGroup_2_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_ExtendAssignment_2_2_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS
+protected class ClassDeclaration_EXTENDSTerminalRuleCall_2_2_1_0 extends UnassignedTextToken {
+
+ public ClassDeclaration_EXTENDSTerminalRuleCall_2_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_NameAssignment_2_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// extend=SuperClass
+protected class ClassDeclaration_ExtendAssignment_2_2_1_1 extends AssignmentToken {
+
+ public ClassDeclaration_ExtendAssignment_2_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("extend",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("extend");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getSuperClassRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_EXTENDSTerminalRuleCall_2_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// body=Block
+protected class ClassDeclaration_BodyAssignment_2_2_2 extends AssignmentToken {
+
+ public ClassDeclaration_BodyAssignment_2_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_2_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_Group_2_2_1(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new ClassDeclaration_NameAssignment_2_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+/************ end Rule ClassDeclaration ****************/
+
+
+/************ begin Rule AssignedClassDeclaration ****************
+ *
+ * / **
+ * * FIXME: it should be the same as ClassDeclaration, but it would result in a non-LL decision,
+ * * so I just removed the problematic options (a class body and a name or a superclass is required).
+ * * / AssignedClassDeclaration:
+ * {ClassDeclaration} CLASS (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)?
+ * body=Block)?;
+ *
+ **/
+
+// {ClassDeclaration} CLASS (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)?
+// body=Block)?
+protected class AssignedClassDeclaration_Group extends GroupToken {
+
+ public AssignedClassDeclaration_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_Alternatives_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignedClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ClassDeclaration}
+protected class AssignedClassDeclaration_ClassDeclarationAction_0 extends ActionToken {
+
+ public AssignedClassDeclaration_ClassDeclarationAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// CLASS
+protected class AssignedClassDeclaration_CLASSTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public AssignedClassDeclaration_CLASSTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_ClassDeclarationAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block)?
+protected class AssignedClassDeclaration_Alternatives_2 extends AlternativesToken {
+
+ public AssignedClassDeclaration_Alternatives_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getAlternatives_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_Group_2_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignedClassDeclaration_Group_2_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS extend=SuperClass body=Block
+protected class AssignedClassDeclaration_Group_2_0 extends GroupToken {
+
+ public AssignedClassDeclaration_Group_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_BodyAssignment_2_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS
+protected class AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_0_0 extends UnassignedTextToken {
+
+ public AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// extend=SuperClass
+protected class AssignedClassDeclaration_ExtendAssignment_2_0_1 extends AssignmentToken {
+
+ public AssignedClassDeclaration_ExtendAssignment_2_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("extend",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("extend");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getSuperClassRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// body=Block
+protected class AssignedClassDeclaration_BodyAssignment_2_0_2 extends AssignmentToken {
+
+ public AssignedClassDeclaration_BodyAssignment_2_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_ExtendAssignment_2_0_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block
+protected class AssignedClassDeclaration_Group_2_1 extends GroupToken {
+
+ public AssignedClassDeclaration_Group_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_BodyAssignment_2_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// name=(Id | Property)
+protected class AssignedClassDeclaration_NameAssignment_2_1_0 extends AssignmentToken {
+
+ public AssignedClassDeclaration_NameAssignment_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getNameAssignment_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ case 1: return new Property_Alternatives(this, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getPropertyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (EXTENDS extend=SuperClass)?
+protected class AssignedClassDeclaration_Group_2_1_1 extends GroupToken {
+
+ public AssignedClassDeclaration_Group_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_ExtendAssignment_2_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS
+protected class AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_1_1_0 extends UnassignedTextToken {
+
+ public AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_NameAssignment_2_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// extend=SuperClass
+protected class AssignedClassDeclaration_ExtendAssignment_2_1_1_1 extends AssignmentToken {
+
+ public AssignedClassDeclaration_ExtendAssignment_2_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("extend",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("extend");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getSuperClassRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// body=Block
+protected class AssignedClassDeclaration_BodyAssignment_2_1_2 extends AssignmentToken {
+
+ public AssignedClassDeclaration_BodyAssignment_2_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_Group_2_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new AssignedClassDeclaration_NameAssignment_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+/************ end Rule AssignedClassDeclaration ****************/
+
+
+/************ begin Rule Expression ****************
+ *
+ * Expression:
+ * Postfix;
+ *
+ **/
+
+// Postfix
+protected class Expression_PostfixParserRuleCall extends RuleCallToken {
+
+ public Expression_PostfixParserRuleCall(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExpressionAccess().getPostfixParserRuleCall();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Postfix_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+/************ end Rule Expression ****************/
+
+
+/************ begin Rule Postfix ****************
+ *
+ * // right-assoc
+ * // Note: the lexer seems to know it should give a POST_IF token here
+ * Postfix returns Expression: //Assignment postfix+=(PostfixIf | ForBody)?;
+ * Assignment (POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE
+ * {While.dummy=current} body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN
+ * when=Expression)?)?;
+ *
+ **/
+
+// //Assignment postfix+=(PostfixIf | ForBody)?;
+// Assignment (POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE
+// {While.dummy=current} body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN
+// when=Expression)?)?
+protected class Postfix_Group extends GroupToken {
+
+ public Postfix_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// //Assignment postfix+=(PostfixIf | ForBody)?;
+// Assignment
+protected class Postfix_AssignmentParserRuleCall_0 extends RuleCallToken {
+
+ public Postfix_AssignmentParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Assignment_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE {While.dummy=current}
+// body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN when=Expression)?)?
+protected class Postfix_Alternatives_1 extends AlternativesToken {
+
+ public Postfix_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Group_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Postfix_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Postfix_Group_1_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new Postfix_Group_1_3(lastRuleCallOrigin, this, 3, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => POST_IF {If.dummy=current} condition=Expression
+protected class Postfix_Group_1_0 extends GroupToken {
+
+ public Postfix_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_ConditionAssignment_1_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => POST_IF
+protected class Postfix_POST_IFTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public Postfix_POST_IFTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {If.dummy=current}
+protected class Postfix_IfDummyAction_1_0_1 extends ActionToken {
+
+ public Postfix_IfDummyAction_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_POST_IFTerminalRuleCall_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("dummy", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("dummy")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// condition=Expression
+protected class Postfix_ConditionAssignment_1_0_2 extends AssignmentToken {
+
+ public Postfix_ConditionAssignment_1_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getConditionAssignment_1_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("condition",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("condition");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_IfDummyAction_1_0_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// => FOR {For.dummy=current} body=ForBody
+protected class Postfix_Group_1_1 extends GroupToken {
+
+ public Postfix_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_BodyAssignment_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => FOR
+protected class Postfix_FORTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public Postfix_FORTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {For.dummy=current}
+protected class Postfix_ForDummyAction_1_1_1 extends ActionToken {
+
+ public Postfix_ForDummyAction_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getForDummyAction_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_FORTerminalRuleCall_1_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("dummy", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("dummy")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// body=ForBody
+protected class Postfix_BodyAssignment_1_1_2 extends AssignmentToken {
+
+ public Postfix_BodyAssignment_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getBodyAssignment_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForBodyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_ForDummyAction_1_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// => WHILE {While.dummy=current} body=Expression (WHEN when=Expression)?
+protected class Postfix_Group_1_2 extends GroupToken {
+
+ public Postfix_Group_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Group_1_2_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Postfix_BodyAssignment_1_2_2(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => WHILE
+protected class Postfix_WHILETerminalRuleCall_1_2_0 extends UnassignedTextToken {
+
+ public Postfix_WHILETerminalRuleCall_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {While.dummy=current}
+protected class Postfix_WhileDummyAction_1_2_1 extends ActionToken {
+
+ public Postfix_WhileDummyAction_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_WHILETerminalRuleCall_1_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("dummy", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("dummy")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// body=Expression
+protected class Postfix_BodyAssignment_1_2_2 extends AssignmentToken {
+
+ public Postfix_BodyAssignment_1_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getBodyAssignment_1_2_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_WhileDummyAction_1_2_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression)?
+protected class Postfix_Group_1_2_3 extends GroupToken {
+
+ public Postfix_Group_1_2_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_2_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_WhenAssignment_1_2_3_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class Postfix_WHENTerminalRuleCall_1_2_3_0 extends UnassignedTextToken {
+
+ public Postfix_WHENTerminalRuleCall_1_2_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_BodyAssignment_1_2_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class Postfix_WhenAssignment_1_2_3_1 extends AssignmentToken {
+
+ public Postfix_WhenAssignment_1_2_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWhenAssignment_1_2_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_WHENTerminalRuleCall_1_2_3_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// => UNTIL {Until.dummy=current} body=Expression (WHEN when=Expression)?
+protected class Postfix_Group_1_3 extends GroupToken {
+
+ public Postfix_Group_1_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Group_1_3_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Postfix_BodyAssignment_1_3_2(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => UNTIL
+protected class Postfix_UNTILTerminalRuleCall_1_3_0 extends UnassignedTextToken {
+
+ public Postfix_UNTILTerminalRuleCall_1_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {Until.dummy=current}
+protected class Postfix_UntilDummyAction_1_3_1 extends ActionToken {
+
+ public Postfix_UntilDummyAction_1_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_UNTILTerminalRuleCall_1_3_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("dummy", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("dummy")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// body=Expression
+protected class Postfix_BodyAssignment_1_3_2 extends AssignmentToken {
+
+ public Postfix_BodyAssignment_1_3_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getBodyAssignment_1_3_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_UntilDummyAction_1_3_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression)?
+protected class Postfix_Group_1_3_3 extends GroupToken {
+
+ public Postfix_Group_1_3_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_3_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_WhenAssignment_1_3_3_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class Postfix_WHENTerminalRuleCall_1_3_3_0 extends UnassignedTextToken {
+
+ public Postfix_WHENTerminalRuleCall_1_3_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_BodyAssignment_1_3_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class Postfix_WhenAssignment_1_3_3_1 extends AssignmentToken {
+
+ public Postfix_WhenAssignment_1_3_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWhenAssignment_1_3_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_WHENTerminalRuleCall_1_3_3_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+
+/************ end Rule Postfix ****************/
+
+
+/************ begin Rule ForBody ****************
+ *
+ * ForBody returns Expression: //FIXME: Range |
+ * OWN? indexes+=ForValue (COMMA indexes+=ForValue)* source=ForSource;
+ *
+ **/
+
+// //FIXME: Range |
+// OWN? indexes+=ForValue (COMMA indexes+=ForValue)* source=ForSource
+protected class ForBody_Group extends GroupToken {
+
+ public ForBody_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_SourceAssignment_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getForBodyRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// indexes+=ForValue
+protected class ForBody_IndexesAssignment_1 extends AssignmentToken {
+
+ public ForBody_IndexesAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getIndexesAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForValue_IdParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("indexes",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("indexes");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForValueRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (COMMA indexes+=ForValue)*
+protected class ForBody_Group_2 extends GroupToken {
+
+ public ForBody_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_IndexesAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class ForBody_COMMATerminalRuleCall_2_0 extends UnassignedTextToken {
+
+ public ForBody_COMMATerminalRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_Group_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForBody_IndexesAssignment_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// indexes+=ForValue
+protected class ForBody_IndexesAssignment_2_1 extends AssignmentToken {
+
+ public ForBody_IndexesAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getIndexesAssignment_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForValue_IdParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("indexes",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("indexes");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForValueRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForBody_COMMATerminalRuleCall_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// source=ForSource
+protected class ForBody_SourceAssignment_3 extends AssignmentToken {
+
+ public ForBody_SourceAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getSourceAssignment_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForSourceRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForBody_Group_2(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new ForBody_IndexesAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule ForBody ****************/
+
+
+/************ begin Rule ForValue ****************
+ *
+ * //FIXME | Array | Dictionary;
+ * ForValue:
+ * Id;
+ *
+ **/
+
+// Id
+protected class ForValue_IdParserRuleCall extends RuleCallToken {
+
+ public ForValue_IdParserRuleCall(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForValueAccess().getIdParserRuleCall();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+/************ end Rule ForValue ****************/
+
+
+/************ begin Rule ForSource ****************
+ *
+ * ForSource:
+ * {ForSource} (FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY
+ * by=Expression)? | BY by=Expression (WHEN when=Expression)?)?);
+ *
+ **/
+
+// {ForSource} (FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY
+// by=Expression)? | BY by=Expression (WHEN when=Expression)?)?)
+protected class ForSource_Group extends GroupToken {
+
+ public ForSource_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getForSourceAccess().getForSourceAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ForSource}
+protected class ForSource_ForSourceAction_0 extends ActionToken {
+
+ public ForSource_ForSourceAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getForSourceAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// => FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY by=Expression)? |
+// BY by=Expression (WHEN when=Expression)?)?
+protected class ForSource_Alternatives_1 extends AlternativesToken {
+
+ public ForSource_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => FOROF source=Expression (WHEN when=Expression)?
+protected class ForSource_Group_1_0 extends GroupToken {
+
+ public ForSource_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_0_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_SourceAssignment_1_0_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => FOROF
+protected class ForSource_FOROFTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public ForSource_FOROFTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_ForSourceAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// source=Expression
+protected class ForSource_SourceAssignment_1_0_1 extends AssignmentToken {
+
+ public ForSource_SourceAssignment_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getSourceAssignment_1_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_FOROFTerminalRuleCall_1_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression)?
+protected class ForSource_Group_1_0_2 extends GroupToken {
+
+ public ForSource_Group_1_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_WhenAssignment_1_0_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class ForSource_WHENTerminalRuleCall_1_0_2_0 extends UnassignedTextToken {
+
+ public ForSource_WHENTerminalRuleCall_1_0_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_SourceAssignment_1_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class ForSource_WhenAssignment_1_0_2_1 extends AssignmentToken {
+
+ public ForSource_WhenAssignment_1_0_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWhenAssignment_1_0_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_WHENTerminalRuleCall_1_0_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// => FORIN source=Expression (WHEN when=Expression (BY by=Expression)? | BY by=Expression (WHEN when=Expression)?)?
+protected class ForSource_Group_1_1 extends GroupToken {
+
+ public ForSource_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Alternatives_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_SourceAssignment_1_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => FORIN
+protected class ForSource_FORINTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public ForSource_FORINTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_ForSourceAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// source=Expression
+protected class ForSource_SourceAssignment_1_1_1 extends AssignmentToken {
+
+ public ForSource_SourceAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getSourceAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_FORINTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression (BY by=Expression)? | BY by=Expression (WHEN when=Expression)?)?
+protected class ForSource_Alternatives_1_1_2 extends AlternativesToken {
+
+ public ForSource_Alternatives_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getAlternatives_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_1_2_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_Group_1_1_2_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN when=Expression (BY by=Expression)?
+protected class ForSource_Group_1_1_2_0 extends GroupToken {
+
+ public ForSource_Group_1_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_1_2_0_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_WhenAssignment_1_1_2_0_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class ForSource_WHENTerminalRuleCall_1_1_2_0_0 extends UnassignedTextToken {
+
+ public ForSource_WHENTerminalRuleCall_1_1_2_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_SourceAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class ForSource_WhenAssignment_1_1_2_0_1 extends AssignmentToken {
+
+ public ForSource_WhenAssignment_1_1_2_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_WHENTerminalRuleCall_1_1_2_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> BY by=Expression)?
+protected class ForSource_Group_1_1_2_0_2 extends GroupToken {
+
+ public ForSource_Group_1_1_2_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1_2_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_ByAssignment_1_1_2_0_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => BY
+protected class ForSource_BYTerminalRuleCall_1_1_2_0_2_0 extends UnassignedTextToken {
+
+ public ForSource_BYTerminalRuleCall_1_1_2_0_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_WhenAssignment_1_1_2_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// by=Expression
+protected class ForSource_ByAssignment_1_1_2_0_2_1 extends AssignmentToken {
+
+ public ForSource_ByAssignment_1_1_2_0_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getByAssignment_1_1_2_0_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("by",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("by");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_BYTerminalRuleCall_1_1_2_0_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// => BY by=Expression (WHEN when=Expression)?
+protected class ForSource_Group_1_1_2_1 extends GroupToken {
+
+ public ForSource_Group_1_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_1_2_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_ByAssignment_1_1_2_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => BY
+protected class ForSource_BYTerminalRuleCall_1_1_2_1_0 extends UnassignedTextToken {
+
+ public ForSource_BYTerminalRuleCall_1_1_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_SourceAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// by=Expression
+protected class ForSource_ByAssignment_1_1_2_1_1 extends AssignmentToken {
+
+ public ForSource_ByAssignment_1_1_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getByAssignment_1_1_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("by",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("by");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_BYTerminalRuleCall_1_1_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression)?
+protected class ForSource_Group_1_1_2_1_2 extends GroupToken {
+
+ public ForSource_Group_1_1_2_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1_2_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_WhenAssignment_1_1_2_1_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class ForSource_WHENTerminalRuleCall_1_1_2_1_2_0 extends UnassignedTextToken {
+
+ public ForSource_WHENTerminalRuleCall_1_1_2_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_ByAssignment_1_1_2_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class ForSource_WhenAssignment_1_1_2_1_2_1 extends AssignmentToken {
+
+ public ForSource_WhenAssignment_1_1_2_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_WHENTerminalRuleCall_1_1_2_1_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+
+
+
+/************ end Rule ForSource ****************/
+
+
+/************ begin Rule Range ****************
+ *
+ * Range:
+ * => (LBRACKET start=Expression (DOT_DOT | ELLIPSIS)) end=Expression RBRACKET;
+ *
+ **/
+
+// => (LBRACKET start=Expression (DOT_DOT | ELLIPSIS)) end=Expression RBRACKET
+protected class Range_Group extends GroupToken {
+
+ public Range_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRangeAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_RBRACKETTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRangeRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (LBRACKET start=Expression (DOT_DOT | ELLIPSIS))
+protected class Range_Group_0 extends GroupToken {
+
+ public Range_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRangeAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_Group_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LBRACKET start=Expression (DOT_DOT | ELLIPSIS)
+protected class Range_Group_0_0 extends GroupToken {
+
+ public Range_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRangeAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_Alternatives_0_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LBRACKET
+protected class Range_LBRACKETTerminalRuleCall_0_0_0 extends UnassignedTextToken {
+
+ public Range_LBRACKETTerminalRuleCall_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// start=Expression
+protected class Range_StartAssignment_0_0_1 extends AssignmentToken {
+
+ public Range_StartAssignment_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRangeAccess().getStartAssignment_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("start",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("start");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Range_LBRACKETTerminalRuleCall_0_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// DOT_DOT | ELLIPSIS
+protected class Range_Alternatives_0_0_2 extends AlternativesToken {
+
+ public Range_Alternatives_0_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getRangeAccess().getAlternatives_0_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_DOT_DOTTerminalRuleCall_0_0_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// DOT_DOT
+protected class Range_DOT_DOTTerminalRuleCall_0_0_2_0 extends UnassignedTextToken {
+
+ public Range_DOT_DOTTerminalRuleCall_0_0_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_StartAssignment_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+// end=Expression
+protected class Range_EndAssignment_1 extends AssignmentToken {
+
+ public Range_EndAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRangeAccess().getEndAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("end",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("end");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Range_Group_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// RBRACKET
+protected class Range_RBRACKETTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public Range_RBRACKETTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_EndAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule Range ****************/
+
+
+/************ begin Rule Assignment ****************
+ *
+ * Assignment returns Expression:
+ * => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned | LogicOp;
+ *
+ **/
+
+// => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned | LogicOp
+protected class Assignment_Alternatives extends AlternativesToken {
+
+ public Assignment_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Assignment_LogicOpParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned
+protected class Assignment_Group_0 extends GroupToken {
+
+ public Assignment_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_RightAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN))
+protected class Assignment_Group_0_0 extends GroupToken {
+
+ public Assignment_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_Group_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)
+protected class Assignment_Group_0_0_0 extends GroupToken {
+
+ public Assignment_Group_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getGroup_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_OperatorAssignment_0_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// left=Assignable
+protected class Assignment_LeftAssignment_0_0_0_0 extends AssignmentToken {
+
+ public Assignment_LeftAssignment_0_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getLeftAssignment_0_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignable_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("left",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("left");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignableRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// operator=(EQUAL | COMPOUND_ASSIGN)
+protected class Assignment_OperatorAssignment_0_0_0_1 extends AssignmentToken {
+
+ public Assignment_OperatorAssignment_0_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getOperatorAssignment_0_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_LeftAssignment_0_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=Assigned
+protected class Assignment_RightAssignment_0_1 extends AssignmentToken {
+
+ public Assignment_RightAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getRightAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignedRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Assignment_Group_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// LogicOp
+protected class Assignment_LogicOpParserRuleCall_1 extends RuleCallToken {
+
+ public Assignment_LogicOpParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(LogicOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Assignment ****************/
+
+
+/************ begin Rule Assigned ****************
+ *
+ * Assigned returns Expression:
+ * Expression | INDENT Expression OUTDENT | AssignedClassDeclaration;
+ *
+ **/
+
+// Expression | INDENT Expression OUTDENT | AssignedClassDeclaration
+protected class Assigned_Alternatives extends AlternativesToken {
+
+ public Assigned_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_ExpressionParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Assigned_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Assigned_AssignedClassDeclarationParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Expression
+protected class Assigned_ExpressionParserRuleCall_0 extends RuleCallToken {
+
+ public Assigned_ExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Expression_PostfixParserRuleCall.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// INDENT Expression OUTDENT
+protected class Assigned_Group_1 extends GroupToken {
+
+ public Assigned_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_OUTDENTTerminalRuleCall_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// INDENT
+protected class Assigned_INDENTTerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public Assigned_INDENTTerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// Expression
+protected class Assigned_ExpressionParserRuleCall_1_1 extends RuleCallToken {
+
+ public Assigned_ExpressionParserRuleCall_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Expression_PostfixParserRuleCall.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_INDENTTerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class Assigned_OUTDENTTerminalRuleCall_1_2 extends UnassignedTextToken {
+
+ public Assigned_OUTDENTTerminalRuleCall_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_ExpressionParserRuleCall_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+// AssignedClassDeclaration
+protected class Assigned_AssignedClassDeclarationParserRuleCall_2 extends RuleCallToken {
+
+ public Assigned_AssignedClassDeclarationParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(AssignedClassDeclaration_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Assigned ****************/
+
+
+/************ begin Rule LogicOp ****************
+ *
+ * LogicOp returns Expression:
+ * CompareOp (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*;
+ *
+ **/
+
+// CompareOp (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*
+protected class LogicOp_Group extends GroupToken {
+
+ public LogicOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new LogicOp_CompareOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// CompareOp
+protected class LogicOp_CompareOpParserRuleCall_0 extends RuleCallToken {
+
+ public LogicOp_CompareOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(CompareOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*
+protected class LogicOp_Group_1 extends GroupToken {
+
+ public LogicOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=LOGIC)
+protected class LogicOp_Group_1_0 extends GroupToken {
+
+ public LogicOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=LOGIC
+protected class LogicOp_Group_1_0_0 extends GroupToken {
+
+ public LogicOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class LogicOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public LogicOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new LogicOp_CompareOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=LOGIC
+protected class LogicOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public LogicOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=CompareOp
+protected class LogicOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public LogicOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getCompareOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new LogicOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule LogicOp ****************/
+
+
+/************ begin Rule CompareOp ****************
+ *
+ * CompareOp returns Expression:
+ * RelationOp (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*;
+ *
+ **/
+
+// RelationOp (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*
+protected class CompareOp_Group extends GroupToken {
+
+ public CompareOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new CompareOp_RelationOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// RelationOp
+protected class CompareOp_RelationOpParserRuleCall_0 extends RuleCallToken {
+
+ public CompareOp_RelationOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(RelationOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*
+protected class CompareOp_Group_1 extends GroupToken {
+
+ public CompareOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=COMPARE)
+protected class CompareOp_Group_1_0 extends GroupToken {
+
+ public CompareOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=COMPARE
+protected class CompareOp_Group_1_0_0 extends GroupToken {
+
+ public CompareOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class CompareOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public CompareOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new CompareOp_RelationOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=COMPARE
+protected class CompareOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public CompareOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=RelationOp
+protected class CompareOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public CompareOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getRelationOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new CompareOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule CompareOp ****************/
+
+
+/************ begin Rule RelationOp ****************
+ *
+ * RelationOp returns Expression:
+ * ShiftOp (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*;
+ *
+ **/
+
+// ShiftOp (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*
+protected class RelationOp_Group extends GroupToken {
+
+ public RelationOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new RelationOp_ShiftOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// ShiftOp
+protected class RelationOp_ShiftOpParserRuleCall_0 extends RuleCallToken {
+
+ public RelationOp_ShiftOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(ShiftOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*
+protected class RelationOp_Group_1 extends GroupToken {
+
+ public RelationOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=RELATION)
+protected class RelationOp_Group_1_0 extends GroupToken {
+
+ public RelationOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=RELATION
+protected class RelationOp_Group_1_0_0 extends GroupToken {
+
+ public RelationOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class RelationOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public RelationOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new RelationOp_ShiftOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=RELATION
+protected class RelationOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public RelationOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=ShiftOp
+protected class RelationOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public RelationOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getShiftOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new RelationOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule RelationOp ****************/
+
+
+/************ begin Rule ShiftOp ****************
+ *
+ * ShiftOp returns Expression:
+ * AdditiveOp (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*;
+ *
+ **/
+
+// AdditiveOp (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*
+protected class ShiftOp_Group extends GroupToken {
+
+ public ShiftOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ShiftOp_AdditiveOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// AdditiveOp
+protected class ShiftOp_AdditiveOpParserRuleCall_0 extends RuleCallToken {
+
+ public ShiftOp_AdditiveOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(AdditiveOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*
+protected class ShiftOp_Group_1 extends GroupToken {
+
+ public ShiftOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=SHIFT)
+protected class ShiftOp_Group_1_0 extends GroupToken {
+
+ public ShiftOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=SHIFT
+protected class ShiftOp_Group_1_0_0 extends GroupToken {
+
+ public ShiftOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class ShiftOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public ShiftOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ShiftOp_AdditiveOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=SHIFT
+protected class ShiftOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public ShiftOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=AdditiveOp
+protected class ShiftOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public ShiftOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAdditiveOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ShiftOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule ShiftOp ****************/
+
+
+/************ begin Rule AdditiveOp ****************
+ *
+ * AdditiveOp returns Expression:
+ * MathOp (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*;
+ *
+ **/
+
+// MathOp (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*
+protected class AdditiveOp_Group extends GroupToken {
+
+ public AdditiveOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AdditiveOp_MathOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// MathOp
+protected class AdditiveOp_MathOpParserRuleCall_0 extends RuleCallToken {
+
+ public AdditiveOp_MathOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(MathOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*
+protected class AdditiveOp_Group_1 extends GroupToken {
+
+ public AdditiveOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=(PLUS | MINUS))
+protected class AdditiveOp_Group_1_0 extends GroupToken {
+
+ public AdditiveOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=(PLUS | MINUS)
+protected class AdditiveOp_Group_1_0_0 extends GroupToken {
+
+ public AdditiveOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class AdditiveOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public AdditiveOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AdditiveOp_MathOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=(PLUS | MINUS)
+protected class AdditiveOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public AdditiveOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=MathOp
+protected class AdditiveOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public AdditiveOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getMathOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AdditiveOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule AdditiveOp ****************/
+
+
+/************ begin Rule MathOp ****************
+ *
+ * MathOp returns Expression:
+ * UnaryOp (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*;
+ *
+ **/
+
+// UnaryOp (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*
+protected class MathOp_Group extends GroupToken {
+
+ public MathOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new MathOp_UnaryOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// UnaryOp
+protected class MathOp_UnaryOpParserRuleCall_0 extends RuleCallToken {
+
+ public MathOp_UnaryOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(UnaryOp_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*
+protected class MathOp_Group_1 extends GroupToken {
+
+ public MathOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=MATH)
+protected class MathOp_Group_1_0 extends GroupToken {
+
+ public MathOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=MATH
+protected class MathOp_Group_1_0_0 extends GroupToken {
+
+ public MathOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class MathOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public MathOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new MathOp_UnaryOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=MATH
+protected class MathOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public MathOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=UnaryOp
+protected class MathOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public MathOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getUnaryOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new MathOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule MathOp ****************/
+
+
+/************ begin Rule UnaryOp ****************
+ *
+ * UnaryOp returns Expression:
+ * (UNARY | PLUS | MINUS) Expression | (PLUS_PLUS | MINUS_MINUS) Variable | // FIXME: postfix increment
+ * Application QUESTION?;
+ *
+ **/
+
+// (UNARY | PLUS | MINUS) Expression | (PLUS_PLUS | MINUS_MINUS) Variable | // FIXME: postfix increment
+// Application QUESTION?
+protected class UnaryOp_Alternatives extends AlternativesToken {
+
+ public UnaryOp_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new UnaryOp_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new UnaryOp_Group_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// (UNARY | PLUS | MINUS) Expression
+protected class UnaryOp_Group_0 extends GroupToken {
+
+ public UnaryOp_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_ExpressionParserRuleCall_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// UNARY | PLUS | MINUS
+protected class UnaryOp_Alternatives_0_0 extends AlternativesToken {
+
+ public UnaryOp_Alternatives_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getAlternatives_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_UNARYTerminalRuleCall_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// UNARY
+protected class UnaryOp_UNARYTerminalRuleCall_0_0_0 extends UnassignedTextToken {
+
+ public UnaryOp_UNARYTerminalRuleCall_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+
+// Expression
+protected class UnaryOp_ExpressionParserRuleCall_0_1 extends RuleCallToken {
+
+ public UnaryOp_ExpressionParserRuleCall_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Expression_PostfixParserRuleCall.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Alternatives_0_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+
+// (PLUS_PLUS | MINUS_MINUS) Variable
+protected class UnaryOp_Group_1 extends GroupToken {
+
+ public UnaryOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_VariableParserRuleCall_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// PLUS_PLUS | MINUS_MINUS
+protected class UnaryOp_Alternatives_1_0 extends AlternativesToken {
+
+ public UnaryOp_Alternatives_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getAlternatives_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_PLUS_PLUSTerminalRuleCall_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// PLUS_PLUS
+protected class UnaryOp_PLUS_PLUSTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public UnaryOp_PLUS_PLUSTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+
+// Variable
+protected class UnaryOp_VariableParserRuleCall_1_1 extends RuleCallToken {
+
+ public UnaryOp_VariableParserRuleCall_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Variable_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Alternatives_1_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+
+// // FIXME: postfix increment
+// Application QUESTION?
+protected class UnaryOp_Group_2 extends GroupToken {
+
+ public UnaryOp_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_ApplicationParserRuleCall_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// // FIXME: postfix increment
+// Application
+protected class UnaryOp_ApplicationParserRuleCall_2_0 extends RuleCallToken {
+
+ public UnaryOp_ApplicationParserRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Application_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+
+/************ end Rule UnaryOp ****************/
+
+
+/************ begin Rule Application ****************
+ *
+ * // Nested function calls and property accesses -- I couldn't come up with a better name
+ * Application:
+ * {SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?) | value=PrimaryExpression features+=FeatureCall*;
+ *
+ **/
+
+// {SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?) | value=PrimaryExpression features+=FeatureCall*
+protected class Application_Alternatives extends AlternativesToken {
+
+ public Application_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Application_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?)
+protected class Application_Group_0 extends GroupToken {
+
+ public Application_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_Group_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {SuperCall}
+protected class Application_SuperCallAction_0_0 extends ActionToken {
+
+ public Application_SuperCallAction_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getSuperCallAction_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// SUPER (CALL_START args=ArgList CALL_END)?
+protected class Application_Group_0_1 extends GroupToken {
+
+ public Application_Group_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getGroup_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_Group_0_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Application_SUPERTerminalRuleCall_0_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// SUPER
+protected class Application_SUPERTerminalRuleCall_0_1_0 extends UnassignedTextToken {
+
+ public Application_SUPERTerminalRuleCall_0_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_SuperCallAction_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// (CALL_START args=ArgList CALL_END)?
+protected class Application_Group_0_1_1 extends GroupToken {
+
+ public Application_Group_0_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getGroup_0_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_CALL_ENDTerminalRuleCall_0_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// CALL_START
+protected class Application_CALL_STARTTerminalRuleCall_0_1_1_0 extends UnassignedTextToken {
+
+ public Application_CALL_STARTTerminalRuleCall_0_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_SUPERTerminalRuleCall_0_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// args=ArgList
+protected class Application_ArgsAssignment_0_1_1_1 extends AssignmentToken {
+
+ public Application_ArgsAssignment_0_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getArgsAssignment_0_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("args",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("args");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgListRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Application_CALL_STARTTerminalRuleCall_0_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// CALL_END
+protected class Application_CALL_ENDTerminalRuleCall_0_1_1_2 extends UnassignedTextToken {
+
+ public Application_CALL_ENDTerminalRuleCall_0_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_ArgsAssignment_0_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+// value=PrimaryExpression features+=FeatureCall*
+protected class Application_Group_1 extends GroupToken {
+
+ public Application_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_FeaturesAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Application_ValueAssignment_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// value=PrimaryExpression
+protected class Application_ValueAssignment_1_0 extends AssignmentToken {
+
+ public Application_ValueAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getValueAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("value",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("value");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getPrimaryExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// features+=FeatureCall*
+protected class Application_FeaturesAssignment_1_1 extends AssignmentToken {
+
+ public Application_FeaturesAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getFeaturesAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FeatureCall_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("features",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("features");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getFeatureCallRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Application_FeaturesAssignment_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new Application_ValueAssignment_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule Application ****************/
+
+
+/************ begin Rule FeatureCall ****************
+ *
+ * FeatureCall:
+ * FunctionCall | PropertyAccess;
+ *
+ **/
+
+// FunctionCall | PropertyAccess
+protected class FeatureCall_Alternatives extends AlternativesToken {
+
+ public FeatureCall_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getFeatureCallAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FeatureCall_FunctionCallParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new FeatureCall_PropertyAccessParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getFunctionCallAccess().getFunctionCallAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// FunctionCall
+protected class FeatureCall_FunctionCallParserRuleCall_0 extends RuleCallToken {
+
+ public FeatureCall_FunctionCallParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FunctionCall_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getFunctionCallAccess().getFunctionCallAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(FunctionCall_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// PropertyAccess
+protected class FeatureCall_PropertyAccessParserRuleCall_1 extends RuleCallToken {
+
+ public FeatureCall_PropertyAccessParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PropertyAccess_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(PropertyAccess_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule FeatureCall ****************/
+
+
+/************ begin Rule FunctionCall ****************
+ *
+ * FunctionCall:
+ * {FunctionCall} FUNC_EXIST? CALL_START args=ArgList CALL_END;
+ *
+ **/
+
+// {FunctionCall} FUNC_EXIST? CALL_START args=ArgList CALL_END
+protected class FunctionCall_Group extends GroupToken {
+
+ public FunctionCall_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FunctionCall_CALL_ENDTerminalRuleCall_4(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getFunctionCallAccess().getFunctionCallAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {FunctionCall}
+protected class FunctionCall_FunctionCallAction_0 extends ActionToken {
+
+ public FunctionCall_FunctionCallAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getFunctionCallAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// CALL_START
+protected class FunctionCall_CALL_STARTTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public FunctionCall_CALL_STARTTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FunctionCall_FunctionCallAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// args=ArgList
+protected class FunctionCall_ArgsAssignment_3 extends AssignmentToken {
+
+ public FunctionCall_ArgsAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getArgsAssignment_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("args",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("args");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgListRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new FunctionCall_CALL_STARTTerminalRuleCall_2(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// CALL_END
+protected class FunctionCall_CALL_ENDTerminalRuleCall_4 extends UnassignedTextToken {
+
+ public FunctionCall_CALL_ENDTerminalRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FunctionCall_ArgsAssignment_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule FunctionCall ****************/
+
+
+/************ begin Rule PropertyAccess ****************
+ *
+ * PropertyAccess:
+ * NamedPropertyAccess | IndexedPropertyAccess;
+ *
+ **/
+
+// NamedPropertyAccess | IndexedPropertyAccess
+protected class PropertyAccess_Alternatives extends AlternativesToken {
+
+ public PropertyAccess_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPropertyAccessAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PropertyAccess_NamedPropertyAccessParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PropertyAccess_IndexedPropertyAccessParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// NamedPropertyAccess
+protected class PropertyAccess_NamedPropertyAccessParserRuleCall_0 extends RuleCallToken {
+
+ public PropertyAccess_NamedPropertyAccessParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NamedPropertyAccess_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(NamedPropertyAccess_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// IndexedPropertyAccess
+protected class PropertyAccess_IndexedPropertyAccessParserRuleCall_1 extends RuleCallToken {
+
+ public PropertyAccess_IndexedPropertyAccessParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IndexedPropertyAccess_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(IndexedPropertyAccess_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule PropertyAccess ****************/
+
+
+/************ begin Rule ThisProperty ****************
+ *
+ * ThisProperty:
+ * AT_SIGIL Id;
+ *
+ **/
+
+// AT_SIGIL Id
+protected class ThisProperty_Group extends GroupToken {
+
+ public ThisProperty_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getThisPropertyAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThisProperty_IdParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// AT_SIGIL
+protected class ThisProperty_AT_SIGILTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public ThisProperty_AT_SIGILTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// Id
+protected class ThisProperty_IdParserRuleCall_1 extends RuleCallToken {
+
+ public ThisProperty_IdParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThisProperty_AT_SIGILTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule ThisProperty ****************/
+
+
+/************ begin Rule NamedPropertyAccess ****************
+ *
+ * NamedPropertyAccess:
+ * accessor=(DOT | QUESTION_DOT) name=Id | accessor=DOUBLE_COLON name=Id?;
+ *
+ **/
+
+// accessor=(DOT | QUESTION_DOT) name=Id | accessor=DOUBLE_COLON name=Id?
+protected class NamedPropertyAccess_Alternatives extends AlternativesToken {
+
+ public NamedPropertyAccess_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NamedPropertyAccess_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new NamedPropertyAccess_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// accessor=(DOT | QUESTION_DOT) name=Id
+protected class NamedPropertyAccess_Group_0 extends GroupToken {
+
+ public NamedPropertyAccess_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NamedPropertyAccess_NameAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// accessor=(DOT | QUESTION_DOT)
+protected class NamedPropertyAccess_AccessorAssignment_0_0 extends AssignmentToken {
+
+ public NamedPropertyAccess_AccessorAssignment_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("accessor",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("accessor");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// name=Id
+protected class NamedPropertyAccess_NameAssignment_0_1 extends AssignmentToken {
+
+ public NamedPropertyAccess_NameAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new NamedPropertyAccess_AccessorAssignment_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// accessor=DOUBLE_COLON name=Id?
+protected class NamedPropertyAccess_Group_1 extends GroupToken {
+
+ public NamedPropertyAccess_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NamedPropertyAccess_NameAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new NamedPropertyAccess_AccessorAssignment_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// accessor=DOUBLE_COLON
+protected class NamedPropertyAccess_AccessorAssignment_1_0 extends AssignmentToken {
+
+ public NamedPropertyAccess_AccessorAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("accessor",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("accessor");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// name=Id?
+protected class NamedPropertyAccess_NameAssignment_1_1 extends AssignmentToken {
+
+ public NamedPropertyAccess_NameAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("name",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new NamedPropertyAccess_AccessorAssignment_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule NamedPropertyAccess ****************/
+
+
+/************ begin Rule IndexedPropertyAccess ****************
+ *
+ * IndexedPropertyAccess:
+ * INDEX_START index=Index INDEX_END;
+ *
+ **/
+
+// INDEX_START index=Index INDEX_END
+protected class IndexedPropertyAccess_Group extends GroupToken {
+
+ public IndexedPropertyAccess_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexedPropertyAccessAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IndexedPropertyAccess_INDEX_ENDTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// INDEX_START
+protected class IndexedPropertyAccess_INDEX_STARTTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public IndexedPropertyAccess_INDEX_STARTTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// index=Index
+protected class IndexedPropertyAccess_IndexAssignment_1 extends AssignmentToken {
+
+ public IndexedPropertyAccess_IndexAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexedPropertyAccessAccess().getIndexAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("index",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("index");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIndexRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new IndexedPropertyAccess_INDEX_STARTTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDEX_END
+protected class IndexedPropertyAccess_INDEX_ENDTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public IndexedPropertyAccess_INDEX_ENDTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IndexedPropertyAccess_IndexAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule IndexedPropertyAccess ****************/
+
+
+/************ begin Rule Index ****************
+ *
+ * Index:
+ * => dots=(DOT_DOT | ELLIPSIS) end=Expression | => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression? |
+ * exp=Expression;
+ *
+ **/
+
+// => dots=(DOT_DOT | ELLIPSIS) end=Expression | => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression? |
+// exp=Expression
+protected class Index_Alternatives extends AlternativesToken {
+
+ public Index_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getIndexAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Index_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Index_ExpAssignment_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => dots=(DOT_DOT | ELLIPSIS) end=Expression
+protected class Index_Group_0 extends GroupToken {
+
+ public Index_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_EndAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => dots=(DOT_DOT | ELLIPSIS)
+protected class Index_DotsAssignment_0_0 extends AssignmentToken {
+
+ public Index_DotsAssignment_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getDotsAssignment_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dots",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dots");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// end=Expression
+protected class Index_EndAssignment_0_1 extends AssignmentToken {
+
+ public Index_EndAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getEndAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("end",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("end");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Index_DotsAssignment_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression?
+protected class Index_Group_1 extends GroupToken {
+
+ public Index_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_EndAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Index_Group_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => (start=Expression dots=(DOT_DOT | ELLIPSIS))
+protected class Index_Group_1_0 extends GroupToken {
+
+ public Index_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// start=Expression dots=(DOT_DOT | ELLIPSIS)
+protected class Index_Group_1_0_0 extends GroupToken {
+
+ public Index_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_DotsAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// start=Expression
+protected class Index_StartAssignment_1_0_0_0 extends AssignmentToken {
+
+ public Index_StartAssignment_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getStartAssignment_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("start",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("start");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// dots=(DOT_DOT | ELLIPSIS)
+protected class Index_DotsAssignment_1_0_0_1 extends AssignmentToken {
+
+ public Index_DotsAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getDotsAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_StartAssignment_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dots",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dots");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// end=Expression?
+protected class Index_EndAssignment_1_1 extends AssignmentToken {
+
+ public Index_EndAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getEndAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("end",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("end");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Index_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// exp=Expression
+protected class Index_ExpAssignment_2 extends AssignmentToken {
+
+ public Index_ExpAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getExpAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exp",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exp");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+
+/************ end Rule Index ****************/
+
+
+/************ begin Rule PrimaryExpression ****************
+ *
+ * // Try Range before Array
+ * PrimaryExpression:
+ * IfExp | Parenthetical | Literal | Range | Array | Dictionary | Lambda | ThisProperty | {ThisAlone} THIS | {For} (FOR
+ * loop=ForBody body=Block) | {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block) | {Until} (UNTIL
+ * loop=Expression (WHEN when=Expression)? body=Block) | {Loop} (LOOP body=Block) | {TryCatch} (TRY body=Block (CATCH
+ * exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?) | {Switch} (SWITCH
+ * exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT) | IdRef;
+ *
+ **/
+
+// IfExp | Parenthetical | Literal | Range | Array | Dictionary | Lambda | ThisProperty | {ThisAlone} THIS | {For} (FOR
+// loop=ForBody body=Block) | {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block) | {Until} (UNTIL
+// loop=Expression (WHEN when=Expression)? body=Block) | {Loop} (LOOP body=Block) | {TryCatch} (TRY body=Block (CATCH
+// exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?) | {Switch} (SWITCH
+// exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT) | IdRef
+protected class PrimaryExpression_Alternatives extends AlternativesToken {
+
+ public PrimaryExpression_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_IfExpParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_ParentheticalParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new PrimaryExpression_LiteralParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new PrimaryExpression_RangeParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
+ case 4: return new PrimaryExpression_ArrayParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
+ case 5: return new PrimaryExpression_DictionaryParserRuleCall_5(lastRuleCallOrigin, this, 5, inst);
+ case 6: return new PrimaryExpression_LambdaParserRuleCall_6(lastRuleCallOrigin, this, 6, inst);
+ case 7: return new PrimaryExpression_ThisPropertyParserRuleCall_7(lastRuleCallOrigin, this, 7, inst);
+ case 8: return new PrimaryExpression_Group_8(lastRuleCallOrigin, this, 8, inst);
+ case 9: return new PrimaryExpression_Group_9(lastRuleCallOrigin, this, 9, inst);
+ case 10: return new PrimaryExpression_Group_10(lastRuleCallOrigin, this, 10, inst);
+ case 11: return new PrimaryExpression_Group_11(lastRuleCallOrigin, this, 11, inst);
+ case 12: return new PrimaryExpression_Group_12(lastRuleCallOrigin, this, 12, inst);
+ case 13: return new PrimaryExpression_Group_13(lastRuleCallOrigin, this, 13, inst);
+ case 14: return new PrimaryExpression_Group_14(lastRuleCallOrigin, this, 14, inst);
+ case 15: return new PrimaryExpression_IdRefParserRuleCall_15(lastRuleCallOrigin, this, 15, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getForAction_9_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIfExpRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getLambdaRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getParentheticalRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRangeRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// IfExp
+protected class PrimaryExpression_IfExpParserRuleCall_0 extends RuleCallToken {
+
+ public PrimaryExpression_IfExpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIfExpRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(IfExp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Parenthetical
+protected class PrimaryExpression_ParentheticalParserRuleCall_1 extends RuleCallToken {
+
+ public PrimaryExpression_ParentheticalParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getParentheticalRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Parenthetical_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Literal
+protected class PrimaryExpression_LiteralParserRuleCall_2 extends RuleCallToken {
+
+ public PrimaryExpression_LiteralParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Literal_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Literal_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Range
+protected class PrimaryExpression_RangeParserRuleCall_3 extends RuleCallToken {
+
+ public PrimaryExpression_RangeParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRangeRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Range_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Array
+protected class PrimaryExpression_ArrayParserRuleCall_4 extends RuleCallToken {
+
+ public PrimaryExpression_ArrayParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Array_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Dictionary
+protected class PrimaryExpression_DictionaryParserRuleCall_5 extends RuleCallToken {
+
+ public PrimaryExpression_DictionaryParserRuleCall_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Dictionary_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Lambda
+protected class PrimaryExpression_LambdaParserRuleCall_6 extends RuleCallToken {
+
+ public PrimaryExpression_LambdaParserRuleCall_6(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getLambdaRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Lambda_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// ThisProperty
+protected class PrimaryExpression_ThisPropertyParserRuleCall_7 extends RuleCallToken {
+
+ public PrimaryExpression_ThisPropertyParserRuleCall_7(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThisProperty_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ThisProperty_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// {ThisAlone} THIS
+protected class PrimaryExpression_Group_8 extends GroupToken {
+
+ public PrimaryExpression_Group_8(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_8();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_THISTerminalRuleCall_8_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ThisAlone}
+protected class PrimaryExpression_ThisAloneAction_8_0 extends ActionToken {
+
+ public PrimaryExpression_ThisAloneAction_8_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// THIS
+protected class PrimaryExpression_THISTerminalRuleCall_8_1 extends UnassignedTextToken {
+
+ public PrimaryExpression_THISTerminalRuleCall_8_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_ThisAloneAction_8_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+// {For} (FOR loop=ForBody body=Block)
+protected class PrimaryExpression_Group_9 extends GroupToken {
+
+ public PrimaryExpression_Group_9(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_9();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_9_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getForAction_9_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {For}
+protected class PrimaryExpression_ForAction_9_0 extends ActionToken {
+
+ public PrimaryExpression_ForAction_9_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getForAction_9_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// FOR loop=ForBody body=Block
+protected class PrimaryExpression_Group_9_1 extends GroupToken {
+
+ public PrimaryExpression_Group_9_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_9_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_9_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// FOR
+protected class PrimaryExpression_FORTerminalRuleCall_9_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_FORTerminalRuleCall_9_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_ForAction_9_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// loop=ForBody
+protected class PrimaryExpression_LoopAssignment_9_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_LoopAssignment_9_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_9_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("loop",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("loop");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForBodyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_FORTerminalRuleCall_9_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_9_1_2 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_9_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_9_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_LoopAssignment_9_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block)
+protected class PrimaryExpression_Group_10 extends GroupToken {
+
+ public PrimaryExpression_Group_10(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_10();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_10_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {While}
+protected class PrimaryExpression_WhileAction_10_0 extends ActionToken {
+
+ public PrimaryExpression_WhileAction_10_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// WHILE loop=Expression (WHEN when=Expression)? body=Block
+protected class PrimaryExpression_Group_10_1 extends GroupToken {
+
+ public PrimaryExpression_Group_10_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_10_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_10_1_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// WHILE
+protected class PrimaryExpression_WHILETerminalRuleCall_10_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_WHILETerminalRuleCall_10_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_WhileAction_10_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// loop=Expression
+protected class PrimaryExpression_LoopAssignment_10_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_LoopAssignment_10_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_10_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("loop",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("loop");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_WHILETerminalRuleCall_10_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (WHEN when=Expression)?
+protected class PrimaryExpression_Group_10_1_2 extends GroupToken {
+
+ public PrimaryExpression_Group_10_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_10_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_WhenAssignment_10_1_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// WHEN
+protected class PrimaryExpression_WHENTerminalRuleCall_10_1_2_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_WHENTerminalRuleCall_10_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_LoopAssignment_10_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class PrimaryExpression_WhenAssignment_10_1_2_1 extends AssignmentToken {
+
+ public PrimaryExpression_WhenAssignment_10_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_10_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_WHENTerminalRuleCall_10_1_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_10_1_3 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_10_1_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_10_1_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_10_1_2(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new PrimaryExpression_LoopAssignment_10_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// {Until} (UNTIL loop=Expression (WHEN when=Expression)? body=Block)
+protected class PrimaryExpression_Group_11 extends GroupToken {
+
+ public PrimaryExpression_Group_11(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_11();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_11_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {Until}
+protected class PrimaryExpression_UntilAction_11_0 extends ActionToken {
+
+ public PrimaryExpression_UntilAction_11_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// UNTIL loop=Expression (WHEN when=Expression)? body=Block
+protected class PrimaryExpression_Group_11_1 extends GroupToken {
+
+ public PrimaryExpression_Group_11_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_11_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_11_1_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// UNTIL
+protected class PrimaryExpression_UNTILTerminalRuleCall_11_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_UNTILTerminalRuleCall_11_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_UntilAction_11_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// loop=Expression
+protected class PrimaryExpression_LoopAssignment_11_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_LoopAssignment_11_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_11_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("loop",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("loop");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_UNTILTerminalRuleCall_11_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (WHEN when=Expression)?
+protected class PrimaryExpression_Group_11_1_2 extends GroupToken {
+
+ public PrimaryExpression_Group_11_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_11_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_WhenAssignment_11_1_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// WHEN
+protected class PrimaryExpression_WHENTerminalRuleCall_11_1_2_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_WHENTerminalRuleCall_11_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_LoopAssignment_11_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class PrimaryExpression_WhenAssignment_11_1_2_1 extends AssignmentToken {
+
+ public PrimaryExpression_WhenAssignment_11_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_11_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_WHENTerminalRuleCall_11_1_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_11_1_3 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_11_1_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_11_1_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_11_1_2(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new PrimaryExpression_LoopAssignment_11_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// {Loop} (LOOP body=Block)
+protected class PrimaryExpression_Group_12 extends GroupToken {
+
+ public PrimaryExpression_Group_12(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_12();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_12_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {Loop}
+protected class PrimaryExpression_LoopAction_12_0 extends ActionToken {
+
+ public PrimaryExpression_LoopAction_12_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// LOOP body=Block
+protected class PrimaryExpression_Group_12_1 extends GroupToken {
+
+ public PrimaryExpression_Group_12_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_12_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_12_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LOOP
+protected class PrimaryExpression_LOOPTerminalRuleCall_12_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_LOOPTerminalRuleCall_12_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_LoopAction_12_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_12_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_12_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_12_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_LOOPTerminalRuleCall_12_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// {TryCatch} (TRY body=Block (CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY
+// finallyBlock=Block)?)
+protected class PrimaryExpression_Group_13 extends GroupToken {
+
+ public PrimaryExpression_Group_13(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_13_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {TryCatch}
+protected class PrimaryExpression_TryCatchAction_13_0 extends ActionToken {
+
+ public PrimaryExpression_TryCatchAction_13_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// TRY body=Block (CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?
+protected class PrimaryExpression_Group_13_1 extends GroupToken {
+
+ public PrimaryExpression_Group_13_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Alternatives_13_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_BodyAssignment_13_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TRY
+protected class PrimaryExpression_TRYTerminalRuleCall_13_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_TRYTerminalRuleCall_13_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_TryCatchAction_13_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_13_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_13_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_13_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_TRYTerminalRuleCall_13_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?
+protected class PrimaryExpression_Alternatives_13_1_2 extends AlternativesToken {
+
+ public PrimaryExpression_Alternatives_13_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getAlternatives_13_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_13_1_2_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_Group_13_1_2_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)?
+protected class PrimaryExpression_Group_13_1_2_0 extends GroupToken {
+
+ public PrimaryExpression_Group_13_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_13_1_2_0_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_CatchBlockAssignment_13_1_2_0_2(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// CATCH
+protected class PrimaryExpression_CATCHTerminalRuleCall_13_1_2_0_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_CATCHTerminalRuleCall_13_1_2_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_13_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// exception=Id
+protected class PrimaryExpression_ExceptionAssignment_13_1_2_0_1 extends AssignmentToken {
+
+ public PrimaryExpression_ExceptionAssignment_13_1_2_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getExceptionAssignment_13_1_2_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exception",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exception");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_CATCHTerminalRuleCall_13_1_2_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// catchBlock=Block
+protected class PrimaryExpression_CatchBlockAssignment_13_1_2_0_2 extends AssignmentToken {
+
+ public PrimaryExpression_CatchBlockAssignment_13_1_2_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getCatchBlockAssignment_13_1_2_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("catchBlock",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("catchBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_ExceptionAssignment_13_1_2_0_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (FINALLY finallyBlock=Block)?
+protected class PrimaryExpression_Group_13_1_2_0_3 extends GroupToken {
+
+ public PrimaryExpression_Group_13_1_2_0_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_FinallyBlockAssignment_13_1_2_0_3_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// FINALLY
+protected class PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_0_3_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_0_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_CatchBlockAssignment_13_1_2_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// finallyBlock=Block
+protected class PrimaryExpression_FinallyBlockAssignment_13_1_2_0_3_1 extends AssignmentToken {
+
+ public PrimaryExpression_FinallyBlockAssignment_13_1_2_0_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_0_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("finallyBlock",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("finallyBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_0_3_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// FINALLY finallyBlock=Block
+protected class PrimaryExpression_Group_13_1_2_1 extends GroupToken {
+
+ public PrimaryExpression_Group_13_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_FinallyBlockAssignment_13_1_2_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// FINALLY
+protected class PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_13_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// finallyBlock=Block
+protected class PrimaryExpression_FinallyBlockAssignment_13_1_2_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_FinallyBlockAssignment_13_1_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("finallyBlock",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("finallyBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+
+// {Switch} (SWITCH exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT)
+protected class PrimaryExpression_Group_14 extends GroupToken {
+
+ public PrimaryExpression_Group_14(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_14();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_14_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {Switch}
+protected class PrimaryExpression_SwitchAction_14_0 extends ActionToken {
+
+ public PrimaryExpression_SwitchAction_14_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// SWITCH exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT
+protected class PrimaryExpression_Group_14_1 extends GroupToken {
+
+ public PrimaryExpression_Group_14_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_14_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_OUTDENTTerminalRuleCall_14_1_5(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// SWITCH
+protected class PrimaryExpression_SWITCHTerminalRuleCall_14_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_SWITCHTerminalRuleCall_14_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_SwitchAction_14_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// exp=Expression?
+protected class PrimaryExpression_ExpAssignment_14_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_ExpAssignment_14_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getExpAssignment_14_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exp",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exp");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_SWITCHTerminalRuleCall_14_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDENT
+protected class PrimaryExpression_INDENTTerminalRuleCall_14_1_2 extends UnassignedTextToken {
+
+ public PrimaryExpression_INDENTTerminalRuleCall_14_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_ExpAssignment_14_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_SWITCHTerminalRuleCall_14_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// cases+=Case*
+protected class PrimaryExpression_CasesAssignment_14_1_3 extends AssignmentToken {
+
+ public PrimaryExpression_CasesAssignment_14_1_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_14_1_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Case_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("cases",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("cases");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getCaseRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_CasesAssignment_14_1_3(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new PrimaryExpression_INDENTTerminalRuleCall_14_1_2(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (ELSE elseBlock=Block)?
+protected class PrimaryExpression_Group_14_1_4 extends GroupToken {
+
+ public PrimaryExpression_Group_14_1_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_14_1_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_ElseBlockAssignment_14_1_4_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// ELSE
+protected class PrimaryExpression_ELSETerminalRuleCall_14_1_4_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_ELSETerminalRuleCall_14_1_4_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_CasesAssignment_14_1_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_INDENTTerminalRuleCall_14_1_2(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// elseBlock=Block
+protected class PrimaryExpression_ElseBlockAssignment_14_1_4_1 extends AssignmentToken {
+
+ public PrimaryExpression_ElseBlockAssignment_14_1_4_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getElseBlockAssignment_14_1_4_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("elseBlock",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elseBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_ELSETerminalRuleCall_14_1_4_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// OUTDENT
+protected class PrimaryExpression_OUTDENTTerminalRuleCall_14_1_5 extends UnassignedTextToken {
+
+ public PrimaryExpression_OUTDENTTerminalRuleCall_14_1_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_14_1_4(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_CasesAssignment_14_1_3(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new PrimaryExpression_INDENTTerminalRuleCall_14_1_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+// IdRef
+protected class PrimaryExpression_IdRefParserRuleCall_15 extends RuleCallToken {
+
+ public PrimaryExpression_IdRefParserRuleCall_15(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IdRef_ValAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(IdRef_ValAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule PrimaryExpression ****************/
+
+
+/************ begin Rule Block ****************
+ *
+ * Block:
+ * {Block} INDENT Body? OUTDENT;
+ *
+ **/
+
+// {Block} INDENT Body? OUTDENT
+protected class Block_Group extends GroupToken {
+
+ public Block_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getBlockAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_OUTDENTTerminalRuleCall_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBlockAccess().getBlockAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getBodyRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {Block}
+protected class Block_BlockAction_0 extends ActionToken {
+
+ public Block_BlockAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getBlockAccess().getBlockAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// INDENT
+protected class Block_INDENTTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public Block_INDENTTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_BlockAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// Body?
+protected class Block_BodyParserRuleCall_2 extends RuleCallToken {
+
+ public Block_BodyParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBlockAccess().getBodyParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Body_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_INDENTTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class Block_OUTDENTTerminalRuleCall_3 extends UnassignedTextToken {
+
+ public Block_OUTDENTTerminalRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_BodyParserRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Block_INDENTTerminalRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule Block ****************/
+
+
+/************ begin Rule Case ****************
+ *
+ * // a switch case (called When in coffeescript)
+ * Case:
+ * LEADING_WHEN whens+=Expression (COMMA whens+=Expression)* then=Block TERMINATOR?;
+ *
+ **/
+
+// LEADING_WHEN whens+=Expression (COMMA whens+=Expression)* then=Block TERMINATOR?
+protected class Case_Group extends GroupToken {
+
+ public Case_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCaseAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Case_ThenAssignment_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCaseRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// LEADING_WHEN
+protected class Case_LEADING_WHENTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public Case_LEADING_WHENTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// whens+=Expression
+protected class Case_WhensAssignment_1 extends AssignmentToken {
+
+ public Case_WhensAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCaseAccess().getWhensAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("whens",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("whens");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Case_LEADING_WHENTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (COMMA whens+=Expression)*
+protected class Case_Group_2 extends GroupToken {
+
+ public Case_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCaseAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Case_WhensAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class Case_COMMATerminalRuleCall_2_0 extends UnassignedTextToken {
+
+ public Case_COMMATerminalRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Case_Group_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Case_WhensAssignment_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// whens+=Expression
+protected class Case_WhensAssignment_2_1 extends AssignmentToken {
+
+ public Case_WhensAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCaseAccess().getWhensAssignment_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("whens",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("whens");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Case_COMMATerminalRuleCall_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// then=Block
+protected class Case_ThenAssignment_3 extends AssignmentToken {
+
+ public Case_ThenAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCaseAccess().getThenAssignment_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("then",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("then");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Case_Group_2(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new Case_WhensAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule Case ****************/
+
+
+/************ begin Rule IfExp ****************
+ *
+ * IfExp:
+ * blocks+=CondBlock (ELSE blocks+=CondBlock)* (ELSE defaultBlock=Block)?;
+ *
+ **/
+
+// blocks+=CondBlock (ELSE blocks+=CondBlock)* (ELSE defaultBlock=Block)?
+protected class IfExp_Group extends GroupToken {
+
+ public IfExp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_Group_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new IfExp_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new IfExp_BlocksAssignment_0(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIfExpRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// blocks+=CondBlock
+protected class IfExp_BlocksAssignment_0 extends AssignmentToken {
+
+ public IfExp_BlocksAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getBlocksAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CondBlock_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("blocks",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("blocks");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getCondBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (ELSE blocks+=CondBlock)*
+protected class IfExp_Group_1 extends GroupToken {
+
+ public IfExp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_BlocksAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// ELSE
+protected class IfExp_ELSETerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public IfExp_ELSETerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new IfExp_BlocksAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// blocks+=CondBlock
+protected class IfExp_BlocksAssignment_1_1 extends AssignmentToken {
+
+ public IfExp_BlocksAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getBlocksAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CondBlock_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("blocks",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("blocks");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getCondBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new IfExp_ELSETerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// (ELSE defaultBlock=Block)?
+protected class IfExp_Group_2 extends GroupToken {
+
+ public IfExp_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_DefaultBlockAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// ELSE
+protected class IfExp_ELSETerminalRuleCall_2_0 extends UnassignedTextToken {
+
+ public IfExp_ELSETerminalRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new IfExp_BlocksAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// defaultBlock=Block
+protected class IfExp_DefaultBlockAssignment_2_1 extends AssignmentToken {
+
+ public IfExp_DefaultBlockAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getDefaultBlockAssignment_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("defaultBlock",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("defaultBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new IfExp_ELSETerminalRuleCall_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule IfExp ****************/
+
+
+/************ begin Rule CondBlock ****************
+ *
+ * // IF can be 'if' or 'unless'
+ * CondBlock:
+ * operator=IF condition=Expression action=Block;
+ *
+ **/
+
+// operator=IF condition=Expression action=Block
+protected class CondBlock_Group extends GroupToken {
+
+ public CondBlock_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCondBlockAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CondBlock_ActionAssignment_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCondBlockRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// operator=IF
+protected class CondBlock_OperatorAssignment_0 extends AssignmentToken {
+
+ public CondBlock_OperatorAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCondBlockAccess().getOperatorAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// condition=Expression
+protected class CondBlock_ConditionAssignment_1 extends AssignmentToken {
+
+ public CondBlock_ConditionAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCondBlockAccess().getConditionAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("condition",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("condition");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new CondBlock_OperatorAssignment_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// action=Block
+protected class CondBlock_ActionAssignment_2 extends AssignmentToken {
+
+ public CondBlock_ActionAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCondBlockAccess().getActionAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("action",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("action");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new CondBlock_ConditionAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule CondBlock ****************/
+
+
+/************ begin Rule IdRef ****************
+ *
+ * IdRef:
+ * val=[Id|IDENTIFIER];
+ *
+ **/
+
+// val=[Id|IDENTIFIER]
+protected class IdRef_ValAssignment extends AssignmentToken {
+
+ public IdRef_ValAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIdRefAccess().getValAssignment();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ if((value = eObjectConsumer.getConsumable("val",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("val");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRefAccess().getValIdCrossReference_0().getType().getClassifier())) {
+ type = AssignmentType.CROSS_REFERENCE;
+ element = grammarAccess.getIdRefAccess().getValIdCrossReference_0();
+ return obj;
+ }
+ }
+ return null;
+ }
+
+}
+
+/************ end Rule IdRef ****************/
+
+
+/************ begin Rule Id ****************
+ *
+ * Id:
+ * name=IDENTIFIER;
+ *
+ **/
+
+// name=IDENTIFIER
+protected class Id_NameAssignment extends AssignmentToken {
+
+ public Id_NameAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIdAccess().getNameAssignment();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+/************ end Rule Id ****************/
+
+
+/************ begin Rule Property ****************
+ *
+ * Property:
+ * => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id // FIXME: property is actually "Expression Accessor"
+ * | => (IdRef INDEX_START) index=Index INDEX_END;
+ *
+ **/
+
+// => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id // FIXME: property is actually "Expression Accessor"
+// | => (IdRef INDEX_START) index=Index INDEX_END
+protected class Property_Alternatives extends AlternativesToken {
+
+ public Property_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Property_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id
+protected class Property_Group_0 extends GroupToken {
+
+ public Property_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_PropAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT))
+protected class Property_Group_0_0 extends GroupToken {
+
+ public Property_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Group_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)
+protected class Property_Group_0_0_0 extends GroupToken {
+
+ public Property_Group_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_AccessorAssignment_0_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// IdRef
+protected class Property_IdRefParserRuleCall_0_0_0_0 extends RuleCallToken {
+
+ public Property_IdRefParserRuleCall_0_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IdRef_ValAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(IdRef_ValAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)
+protected class Property_AccessorAssignment_0_0_0_1 extends AssignmentToken {
+
+ public Property_AccessorAssignment_0_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getAccessorAssignment_0_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_IdRefParserRuleCall_0_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("accessor",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("accessor");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// prop=Id
+protected class Property_PropAssignment_0_1 extends AssignmentToken {
+
+ public Property_PropAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getPropAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("prop",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("prop");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Property_Group_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// => (IdRef INDEX_START) index=Index INDEX_END
+protected class Property_Group_1 extends GroupToken {
+
+ public Property_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_INDEX_ENDTerminalRuleCall_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => (IdRef INDEX_START)
+protected class Property_Group_1_0 extends GroupToken {
+
+ public Property_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// IdRef INDEX_START
+protected class Property_Group_1_0_0 extends GroupToken {
+
+ public Property_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_INDEX_STARTTerminalRuleCall_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// IdRef
+protected class Property_IdRefParserRuleCall_1_0_0_0 extends RuleCallToken {
+
+ public Property_IdRefParserRuleCall_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IdRef_ValAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(IdRef_ValAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// INDEX_START
+protected class Property_INDEX_STARTTerminalRuleCall_1_0_0_1 extends UnassignedTextToken {
+
+ public Property_INDEX_STARTTerminalRuleCall_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_IdRefParserRuleCall_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+// index=Index
+protected class Property_IndexAssignment_1_1 extends AssignmentToken {
+
+ public Property_IndexAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getIndexAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("index",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("index");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIndexRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Property_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDEX_END
+protected class Property_INDEX_ENDTerminalRuleCall_1_2 extends UnassignedTextToken {
+
+ public Property_INDEX_ENDTerminalRuleCall_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_IndexAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+/************ end Rule Property ****************/
+
+
+/************ begin Rule Variable ****************
+ *
+ * Variable:
+ * Id | (AT_SIGIL | THIS DOT) Id (DOT props+=Id)* | Property;
+ *
+ **/
+
+// Id | (AT_SIGIL | THIS DOT) Id (DOT props+=Id)* | Property
+protected class Variable_Alternatives extends AlternativesToken {
+
+ public Variable_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getVariableAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_IdParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Variable_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Variable_PropertyParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Id
+protected class Variable_IdParserRuleCall_0 extends RuleCallToken {
+
+ public Variable_IdParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getIdParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (AT_SIGIL | THIS DOT) Id (DOT props+=Id)*
+protected class Variable_Group_1 extends GroupToken {
+
+ public Variable_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getVariableAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Group_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Variable_IdParserRuleCall_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// AT_SIGIL | THIS DOT
+protected class Variable_Alternatives_1_0 extends AlternativesToken {
+
+ public Variable_Alternatives_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getVariableAccess().getAlternatives_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_AT_SIGILTerminalRuleCall_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// AT_SIGIL
+protected class Variable_AT_SIGILTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public Variable_AT_SIGILTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+
+// Id
+protected class Variable_IdParserRuleCall_1_1 extends RuleCallToken {
+
+ public Variable_IdParserRuleCall_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getIdParserRuleCall_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Alternatives_1_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// (DOT props+=Id)*
+protected class Variable_Group_1_2 extends GroupToken {
+
+ public Variable_Group_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getVariableAccess().getGroup_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_PropsAssignment_1_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// DOT
+protected class Variable_DOTTerminalRuleCall_1_2_0 extends UnassignedTextToken {
+
+ public Variable_DOTTerminalRuleCall_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Group_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Variable_IdParserRuleCall_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// props+=Id
+protected class Variable_PropsAssignment_1_2_1 extends AssignmentToken {
+
+ public Variable_PropsAssignment_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getVariableAccess().getPropsAssignment_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("props",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("props");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Variable_DOTTerminalRuleCall_1_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// Property
+protected class Variable_PropertyParserRuleCall_2 extends RuleCallToken {
+
+ public Variable_PropertyParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getPropertyParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Property_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Variable ****************/
+
+
+/************ begin Rule AssignableArray ****************
+ *
+ * / ** An array that can be on the left-hand side of an assignment * / AssignableArray:
+ * LBRACKET AssignableArgList RBRACKET;
+ *
+ **/
+
+// => LBRACKET AssignableArgList RBRACKET
+protected class AssignableArray_Group extends GroupToken {
+
+ public AssignableArray_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignableArrayAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArray_RBRACKETTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgListRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => LBRACKET
+protected class AssignableArray_LBRACKETTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public AssignableArray_LBRACKETTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// AssignableArgList
+protected class AssignableArray_AssignableArgListParserRuleCall_1 extends RuleCallToken {
+
+ public AssignableArray_AssignableArgListParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(AssignableArgList_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArray_LBRACKETTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// RBRACKET
+protected class AssignableArray_RBRACKETTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public AssignableArray_RBRACKETTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArray_AssignableArgListParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule AssignableArray ****************/
+
+
+/************ begin Rule AssignableArgList ****************
+ *
+ * AssignableArgList:
+ * args+=AssignableArg (COMMA args+=AssignableArg)*;
+ *
+ **/
+
+// args+=AssignableArg (COMMA args+=AssignableArg)*
+protected class AssignableArgList_Group extends GroupToken {
+
+ public AssignableArgList_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArgList_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignableArgList_ArgsAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgListRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// args+=AssignableArg
+protected class AssignableArgList_ArgsAssignment_0 extends AssignmentToken {
+
+ public AssignableArgList_ArgsAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getArgsAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArg_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("args",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("args");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignableArgRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (COMMA args+=AssignableArg)*
+protected class AssignableArgList_Group_1 extends GroupToken {
+
+ public AssignableArgList_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArgList_ArgsAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class AssignableArgList_COMMATerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public AssignableArgList_COMMATerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArgList_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignableArgList_ArgsAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// args+=AssignableArg
+protected class AssignableArgList_ArgsAssignment_1_1 extends AssignmentToken {
+
+ public AssignableArgList_ArgsAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getArgsAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArg_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("args",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("args");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignableArgRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignableArgList_COMMATerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule AssignableArgList ****************/
+
+
+/************ begin Rule AssignableArg ****************
+ *
+ * AssignableArg:
+ * arg=Assignable splat?=ELLIPSIS?;
+ *
+ **/
+
+// arg=Assignable splat?=ELLIPSIS?
+protected class AssignableArg_Group extends GroupToken {
+
+ public AssignableArg_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignableArgAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArg_SplatAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignableArg_ArgAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// arg=Assignable
+protected class AssignableArg_ArgAssignment_0 extends AssignmentToken {
+
+ public AssignableArg_ArgAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignableArgAccess().getArgAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignable_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("arg",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("arg");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignableRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// splat?=ELLIPSIS?
+protected class AssignableArg_SplatAssignment_1 extends AssignmentToken {
+
+ public AssignableArg_SplatAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignableArgAccess().getSplatAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArg_ArgAssignment_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("splat",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("splat");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+/************ end Rule AssignableArg ****************/
+
+
+/************ begin Rule Assignable ****************
+ *
+ * Assignable:
+ * Variable | Dictionary | AssignableArray;
+ *
+ **/
+
+// Variable | Dictionary | AssignableArray
+protected class Assignable_Alternatives extends AlternativesToken {
+
+ public Assignable_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getAssignableAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignable_VariableParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Assignable_DictionaryParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Assignable_AssignableArrayParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgListRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Variable
+protected class Assignable_VariableParserRuleCall_0 extends RuleCallToken {
+
+ public Assignable_VariableParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableAccess().getVariableParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Variable_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Dictionary
+protected class Assignable_DictionaryParserRuleCall_1 extends RuleCallToken {
+
+ public Assignable_DictionaryParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Dictionary_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// AssignableArray
+protected class Assignable_AssignableArrayParserRuleCall_2 extends RuleCallToken {
+
+ public Assignable_AssignableArrayParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArray_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgListRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(AssignableArray_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Assignable ****************/
+
+
+/************ begin Rule Arg ****************
+ *
+ * / *
+ * * FIXME: handle more complex assignables
+ * * / Arg:
+ * exp=Expression splat?=ELLIPSIS?;
+ *
+ **/
+
+// exp=Expression splat?=ELLIPSIS?
+protected class Arg_Group extends GroupToken {
+
+ public Arg_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Arg_SplatAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Arg_ExpAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// exp=Expression
+protected class Arg_ExpAssignment_0 extends AssignmentToken {
+
+ public Arg_ExpAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgAccess().getExpAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exp",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exp");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// splat?=ELLIPSIS?
+protected class Arg_SplatAssignment_1 extends AssignmentToken {
+
+ public Arg_SplatAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgAccess().getSplatAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Arg_ExpAssignment_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("splat",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("splat");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+/************ end Rule Arg ****************/
+
+
+/************ begin Rule ArgLine ****************
+ *
+ * ArgLine:
+ * head=Arg (COMMA tail+=Arg)* COMMA?;
+ *
+ **/
+
+// head=Arg (COMMA tail+=Arg)* COMMA?
+protected class ArgLine_Group extends GroupToken {
+
+ public ArgLine_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ArgLine_HeadAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgLineRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// head=Arg
+protected class ArgLine_HeadAssignment_0 extends AssignmentToken {
+
+ public ArgLine_HeadAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getHeadAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Arg_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("head",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("head");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (COMMA tail+=Arg)*
+protected class ArgLine_Group_1 extends GroupToken {
+
+ public ArgLine_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_TailAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class ArgLine_COMMATerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public ArgLine_COMMATerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ArgLine_HeadAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// tail+=Arg
+protected class ArgLine_TailAssignment_1_1 extends AssignmentToken {
+
+ public ArgLine_TailAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getTailAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Arg_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("tail",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("tail");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ArgLine_COMMATerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule ArgLine ****************/
+
+
+/************ begin Rule ExplicitArgList ****************
+ *
+ * ExplicitArgList:
+ * lines+=ArgLine (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*;
+ *
+ **/
+
+// lines+=ArgLine (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*
+protected class ExplicitArgList_Group extends GroupToken {
+
+ public ExplicitArgList_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitArgList_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getExplicitArgListRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// lines+=ArgLine
+protected class ExplicitArgList_LinesAssignment_0 extends AssignmentToken {
+
+ public ExplicitArgList_LinesAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getLinesAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*
+protected class ExplicitArgList_Alternatives_1 extends AlternativesToken {
+
+ public ExplicitArgList_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Group_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitArgList_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR lines+=ArgLine
+protected class ExplicitArgList_Group_1_0 extends GroupToken {
+
+ public ExplicitArgList_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_LinesAssignment_1_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR
+protected class ExplicitArgList_TERMINATORTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public ExplicitArgList_TERMINATORTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitArgList_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=ArgLine
+protected class ExplicitArgList_LinesAssignment_1_0_1 extends AssignmentToken {
+
+ public ExplicitArgList_LinesAssignment_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ExplicitArgList_TERMINATORTerminalRuleCall_1_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// INDENT lines+=ArgLine OUTDENT
+protected class ExplicitArgList_Group_1_1 extends GroupToken {
+
+ public ExplicitArgList_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_OUTDENTTerminalRuleCall_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class ExplicitArgList_INDENTTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public ExplicitArgList_INDENTTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitArgList_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=ArgLine
+protected class ExplicitArgList_LinesAssignment_1_1_1 extends AssignmentToken {
+
+ public ExplicitArgList_LinesAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ExplicitArgList_INDENTTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class ExplicitArgList_OUTDENTTerminalRuleCall_1_1_2 extends UnassignedTextToken {
+
+ public ExplicitArgList_OUTDENTTerminalRuleCall_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_LinesAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+/************ end Rule ExplicitArgList ****************/
+
+
+/************ begin Rule ArgList ****************
+ *
+ * ArgList:
+ * {ArgList} (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?;
+ *
+ **/
+
+// {ArgList} (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?
+protected class ArgList_Group extends GroupToken {
+
+ public ArgList_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgListAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ArgList_ArgListAction_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ArgList}
+protected class ArgList_ArgListAction_0 extends ActionToken {
+
+ public ArgList_ArgListAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getArgListAccess().getArgListAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?
+protected class ArgList_Alternatives_1 extends AlternativesToken {
+
+ public ArgList_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getArgListAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_DummyAssignment_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ArgList_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// dummy=ExplicitArgList
+protected class ArgList_DummyAssignment_1_0 extends AssignmentToken {
+
+ public ArgList_DummyAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgListAccess().getDummyAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dummy",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dummy");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExplicitArgListRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ArgList_ArgListAction_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDENT dummy=ExplicitArgList OUTDENT
+protected class ArgList_Group_1_1 extends GroupToken {
+
+ public ArgList_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgListAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_OUTDENTTerminalRuleCall_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class ArgList_INDENTTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public ArgList_INDENTTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_ArgListAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// dummy=ExplicitArgList
+protected class ArgList_DummyAssignment_1_1_1 extends AssignmentToken {
+
+ public ArgList_DummyAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgListAccess().getDummyAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dummy",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dummy");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExplicitArgListRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ArgList_INDENTTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class ArgList_OUTDENTTerminalRuleCall_1_1_2 extends UnassignedTextToken {
+
+ public ArgList_OUTDENTTerminalRuleCall_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_DummyAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+/************ end Rule ArgList ****************/
+
+
+/************ begin Rule Array ****************
+ *
+ * Array:
+ * LBRACKET ArgList RBRACKET;
+ *
+ **/
+
+// => LBRACKET ArgList RBRACKET
+protected class Array_Group extends GroupToken {
+
+ public Array_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArrayAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_RBRACKETTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => LBRACKET
+protected class Array_LBRACKETTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public Array_LBRACKETTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// ArgList
+protected class Array_ArgListParserRuleCall_1 extends RuleCallToken {
+
+ public Array_ArgListParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArrayAccess().getArgListParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(ArgList_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_LBRACKETTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// RBRACKET
+protected class Array_RBRACKETTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public Array_RBRACKETTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_ArgListParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule Array ****************/
+
+
+/************ begin Rule Dictionary ****************
+ *
+ * // Object in coffeescript
+ * Dictionary:
+ * LCURLY DictItems RCURLY;
+ *
+ **/
+
+// => LCURLY DictItems RCURLY
+protected class Dictionary_Group extends GroupToken {
+
+ public Dictionary_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictionaryAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_RCURLYTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => LCURLY
+protected class Dictionary_LCURLYTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public Dictionary_LCURLYTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// DictItems
+protected class Dictionary_DictItemsParserRuleCall_1 extends RuleCallToken {
+
+ public Dictionary_DictItemsParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(DictItems_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_LCURLYTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// RCURLY
+protected class Dictionary_RCURLYTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public Dictionary_RCURLYTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_DictItemsParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule Dictionary ****************/
+
+
+/************ begin Rule DictItems ****************
+ *
+ * DictItems:
+ * {DictItems} (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?;
+ *
+ **/
+
+// {DictItems} (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?
+protected class DictItems_Group extends GroupToken {
+
+ public DictItems_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictItems_DictItemsAction_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {DictItems}
+protected class DictItems_DictItemsAction_0 extends ActionToken {
+
+ public DictItems_DictItemsAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getDictItemsAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?
+protected class DictItems_Alternatives_1 extends AlternativesToken {
+
+ public DictItems_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_DummyAssignment_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictItems_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// dummy=ExplicitDictItems
+protected class DictItems_DummyAssignment_1_0 extends AssignmentToken {
+
+ public DictItems_DummyAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getDummyAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dummy",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dummy");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExplicitDictItemsRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItems_DictItemsAction_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDENT dummy=ExplicitDictItems OUTDENT
+protected class DictItems_Group_1_1 extends GroupToken {
+
+ public DictItems_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_OUTDENTTerminalRuleCall_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class DictItems_INDENTTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public DictItems_INDENTTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_DictItemsAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// dummy=ExplicitDictItems
+protected class DictItems_DummyAssignment_1_1_1 extends AssignmentToken {
+
+ public DictItems_DummyAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getDummyAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dummy",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dummy");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExplicitDictItemsRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItems_INDENTTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class DictItems_OUTDENTTerminalRuleCall_1_1_2 extends UnassignedTextToken {
+
+ public DictItems_OUTDENTTerminalRuleCall_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_DummyAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+/************ end Rule DictItems ****************/
+
+
+/************ begin Rule ExplicitDictItems ****************
+ *
+ * ExplicitDictItems:
+ * lines+=DictLine (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*;
+ *
+ **/
+
+// lines+=DictLine (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*
+protected class ExplicitDictItems_Group extends GroupToken {
+
+ public ExplicitDictItems_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitDictItems_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getExplicitDictItemsRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// lines+=DictLine
+protected class ExplicitDictItems_LinesAssignment_0 extends AssignmentToken {
+
+ public ExplicitDictItems_LinesAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*
+protected class ExplicitDictItems_Alternatives_1 extends AlternativesToken {
+
+ public ExplicitDictItems_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Group_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitDictItems_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR lines+=DictLine
+protected class ExplicitDictItems_Group_1_0 extends GroupToken {
+
+ public ExplicitDictItems_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_LinesAssignment_1_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR
+protected class ExplicitDictItems_TERMINATORTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public ExplicitDictItems_TERMINATORTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitDictItems_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=DictLine
+protected class ExplicitDictItems_LinesAssignment_1_0_1 extends AssignmentToken {
+
+ public ExplicitDictItems_LinesAssignment_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ExplicitDictItems_TERMINATORTerminalRuleCall_1_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// INDENT lines+=DictLine OUTDENT
+protected class ExplicitDictItems_Group_1_1 extends GroupToken {
+
+ public ExplicitDictItems_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_OUTDENTTerminalRuleCall_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class ExplicitDictItems_INDENTTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public ExplicitDictItems_INDENTTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitDictItems_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=DictLine
+protected class ExplicitDictItems_LinesAssignment_1_1_1 extends AssignmentToken {
+
+ public ExplicitDictItems_LinesAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ExplicitDictItems_INDENTTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class ExplicitDictItems_OUTDENTTerminalRuleCall_1_1_2 extends UnassignedTextToken {
+
+ public ExplicitDictItems_OUTDENTTerminalRuleCall_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_LinesAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+/************ end Rule ExplicitDictItems ****************/
+
+
+/************ begin Rule DictLine ****************
+ *
+ * DictLine:
+ * head=DictItem (COMMA tail+=DictItem)* COMMA?;
+ *
+ **/
+
+// head=DictItem (COMMA tail+=DictItem)* COMMA?
+protected class DictLine_Group extends GroupToken {
+
+ public DictLine_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictLine_HeadAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictLineRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// head=DictItem
+protected class DictLine_HeadAssignment_0 extends AssignmentToken {
+
+ public DictLine_HeadAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getHeadAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("head",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("head");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictItemRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (COMMA tail+=DictItem)*
+protected class DictLine_Group_1 extends GroupToken {
+
+ public DictLine_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_TailAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class DictLine_COMMATerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public DictLine_COMMATerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictLine_HeadAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// tail+=DictItem
+protected class DictLine_TailAssignment_1_1 extends AssignmentToken {
+
+ public DictLine_TailAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getTailAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("tail",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("tail");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictItemRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictLine_COMMATerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule DictLine ****************/
+
+
+/************ begin Rule DictItem ****************
+ *
+ * DictItem:
+ * {DictItem} key=DictKey (COLON (value=Expression | INDENT value=Expression OUTDENT))?;
+ *
+ **/
+
+// {DictItem} key=DictKey (COLON (value=Expression | INDENT value=Expression OUTDENT))?
+protected class DictItem_Group extends GroupToken {
+
+ public DictItem_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_Group_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictItem_KeyAssignment_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemAccess().getDictItemAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {DictItem}
+protected class DictItem_DictItemAction_0 extends ActionToken {
+
+ public DictItem_DictItemAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getDictItemAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// key=DictKey
+protected class DictItem_KeyAssignment_1 extends AssignmentToken {
+
+ public DictItem_KeyAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getKeyAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictKey_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("key",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("key");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictKeyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItem_DictItemAction_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (COLON (value=Expression | INDENT value=Expression OUTDENT))?
+protected class DictItem_Group_2 extends GroupToken {
+
+ public DictItem_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_Alternatives_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COLON
+protected class DictItem_COLONTerminalRuleCall_2_0 extends UnassignedTextToken {
+
+ public DictItem_COLONTerminalRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_KeyAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// value=Expression | INDENT value=Expression OUTDENT
+protected class DictItem_Alternatives_2_1 extends AlternativesToken {
+
+ public DictItem_Alternatives_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getAlternatives_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_ValueAssignment_2_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictItem_Group_2_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// value=Expression
+protected class DictItem_ValueAssignment_2_1_0 extends AssignmentToken {
+
+ public DictItem_ValueAssignment_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getValueAssignment_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("value",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("value");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItem_COLONTerminalRuleCall_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDENT value=Expression OUTDENT
+protected class DictItem_Group_2_1_1 extends GroupToken {
+
+ public DictItem_Group_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getGroup_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_OUTDENTTerminalRuleCall_2_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class DictItem_INDENTTerminalRuleCall_2_1_1_0 extends UnassignedTextToken {
+
+ public DictItem_INDENTTerminalRuleCall_2_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_COLONTerminalRuleCall_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// value=Expression
+protected class DictItem_ValueAssignment_2_1_1_1 extends AssignmentToken {
+
+ public DictItem_ValueAssignment_2_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getValueAssignment_2_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("value",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("value");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItem_INDENTTerminalRuleCall_2_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class DictItem_OUTDENTTerminalRuleCall_2_1_1_2 extends UnassignedTextToken {
+
+ public DictItem_OUTDENTTerminalRuleCall_2_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_ValueAssignment_2_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+
+/************ end Rule DictItem ****************/
+
+
+/************ begin Rule DictKey ****************
+ *
+ * DictKey:
+ * Literal | Id;
+ *
+ **/
+
+// Literal | Id
+protected class DictKey_Alternatives extends AlternativesToken {
+
+ public DictKey_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getDictKeyAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictKey_LiteralParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictKey_IdParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Literal
+protected class DictKey_LiteralParserRuleCall_0 extends RuleCallToken {
+
+ public DictKey_LiteralParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Literal_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Literal_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Id
+protected class DictKey_IdParserRuleCall_1 extends RuleCallToken {
+
+ public DictKey_IdParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictKeyAccess().getIdParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule DictKey ****************/
+
+
+/************ begin Rule Lambda ****************
+ *
+ * // Code in coffeescript
+ * Lambda:
+ * (PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)? (FUNC_ARROW | BOUND_FUNC_ARROW) body=Block;
+ *
+ **/
+
+// (PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)? (FUNC_ARROW | BOUND_FUNC_ARROW) body=Block
+protected class Lambda_Group extends GroupToken {
+
+ public Lambda_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_BodyAssignment_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getLambdaRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// (PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)?
+protected class Lambda_Group_0 extends GroupToken {
+
+ public Lambda_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_PARAM_ENDTerminalRuleCall_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// PARAM_START
+protected class Lambda_PARAM_STARTTerminalRuleCall_0_0 extends UnassignedTextToken {
+
+ public Lambda_PARAM_STARTTerminalRuleCall_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// (params+=Param (COMMA params+=Param)*)?
+protected class Lambda_Group_0_1 extends GroupToken {
+
+ public Lambda_Group_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getGroup_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group_0_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Lambda_ParamsAssignment_0_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// params+=Param
+protected class Lambda_ParamsAssignment_0_1_0 extends AssignmentToken {
+
+ public Lambda_ParamsAssignment_0_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getParamsAssignment_0_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("params",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("params");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getParamRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Lambda_PARAM_STARTTerminalRuleCall_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (COMMA params+=Param)*
+protected class Lambda_Group_0_1_1 extends GroupToken {
+
+ public Lambda_Group_0_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getGroup_0_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_ParamsAssignment_0_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class Lambda_COMMATerminalRuleCall_0_1_1_0 extends UnassignedTextToken {
+
+ public Lambda_COMMATerminalRuleCall_0_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group_0_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Lambda_ParamsAssignment_0_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// params+=Param
+protected class Lambda_ParamsAssignment_0_1_1_1 extends AssignmentToken {
+
+ public Lambda_ParamsAssignment_0_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getParamsAssignment_0_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("params",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("params");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getParamRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Lambda_COMMATerminalRuleCall_0_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// PARAM_END
+protected class Lambda_PARAM_ENDTerminalRuleCall_0_2 extends UnassignedTextToken {
+
+ public Lambda_PARAM_ENDTerminalRuleCall_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group_0_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Lambda_PARAM_STARTTerminalRuleCall_0_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+// FUNC_ARROW | BOUND_FUNC_ARROW
+protected class Lambda_Alternatives_1 extends AlternativesToken {
+
+ public Lambda_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_FUNC_ARROWTerminalRuleCall_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// FUNC_ARROW
+protected class Lambda_FUNC_ARROWTerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public Lambda_FUNC_ARROWTerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group_0(lastRuleCallOrigin, this, 0, inst);
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index - 1, inst);
+ }
+ }
+
+}
+
+
+// body=Block
+protected class Lambda_BodyAssignment_2 extends AssignmentToken {
+
+ public Lambda_BodyAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getBodyAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Lambda_Alternatives_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule Lambda ****************/
+
+
+/************ begin Rule Param ****************
+ *
+ * Param:
+ * (Id | Array | Dictionary | ThisProperty) (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?;
+ *
+ **/
+
+// (Id | Array | Dictionary | ThisProperty) (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?
+protected class Param_Group extends GroupToken {
+
+ public Param_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParamAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Param_Alternatives_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Id | Array | Dictionary | ThisProperty
+protected class Param_Alternatives_0 extends AlternativesToken {
+
+ public Param_Alternatives_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getParamAccess().getAlternatives_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_IdParserRuleCall_0_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Param_ArrayParserRuleCall_0_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Param_DictionaryParserRuleCall_0_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new Param_ThisPropertyParserRuleCall_0_3(lastRuleCallOrigin, this, 3, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// Id
+protected class Param_IdParserRuleCall_0_0 extends RuleCallToken {
+
+ public Param_IdParserRuleCall_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getIdParserRuleCall_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Array
+protected class Param_ArrayParserRuleCall_0_1 extends RuleCallToken {
+
+ public Param_ArrayParserRuleCall_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getArrayParserRuleCall_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Array_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Dictionary
+protected class Param_DictionaryParserRuleCall_0_2 extends RuleCallToken {
+
+ public Param_DictionaryParserRuleCall_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Dictionary_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// ThisProperty
+protected class Param_ThisPropertyParserRuleCall_0_3 extends RuleCallToken {
+
+ public Param_ThisPropertyParserRuleCall_0_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThisProperty_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ThisProperty_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+// (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?
+protected class Param_Alternatives_1 extends AlternativesToken {
+
+ public Param_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getParamAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_SplatAssignment_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Param_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// splat?=ELLIPSIS
+protected class Param_SplatAssignment_1_0 extends AssignmentToken {
+
+ public Param_SplatAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getParamAccess().getSplatAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Alternatives_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("splat",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("splat");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// EQUAL defaultValue=Expression
+protected class Param_Group_1_1 extends GroupToken {
+
+ public Param_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParamAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_DefaultValueAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EQUAL
+protected class Param_EQUALTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public Param_EQUALTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Alternatives_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// defaultValue=Expression
+protected class Param_DefaultValueAssignment_1_1_1 extends AssignmentToken {
+
+ public Param_DefaultValueAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getParamAccess().getDefaultValueAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("defaultValue",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("defaultValue");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Param_EQUALTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+/************ end Rule Param ****************/
+
+
+/************ begin Rule NumberLiteral ****************
+ *
+ * NumberLiteral:
+ * {NumberLiteral} NUMBER;
+ *
+ **/
+
+// {NumberLiteral} NUMBER
+protected class NumberLiteral_Group extends GroupToken {
+
+ public NumberLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getNumberLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NumberLiteral_NUMBERTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {NumberLiteral}
+protected class NumberLiteral_NumberLiteralAction_0 extends ActionToken {
+
+ public NumberLiteral_NumberLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// NUMBER
+protected class NumberLiteral_NUMBERTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public NumberLiteral_NUMBERTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NumberLiteral_NumberLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule NumberLiteral ****************/
+
+
+/************ begin Rule StringLiteral ****************
+ *
+ * StringLiteral:
+ * {StringLiteral} STRING;
+ *
+ **/
+
+// {StringLiteral} STRING
+protected class StringLiteral_Group extends GroupToken {
+
+ public StringLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getStringLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new StringLiteral_STRINGTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {StringLiteral}
+protected class StringLiteral_StringLiteralAction_0 extends ActionToken {
+
+ public StringLiteral_StringLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getStringLiteralAccess().getStringLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// STRING
+protected class StringLiteral_STRINGTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public StringLiteral_STRINGTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new StringLiteral_StringLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule StringLiteral ****************/
+
+
+/************ begin Rule BoolLiteral ****************
+ *
+ * BoolLiteral:
+ * {BoolLiteral} BOOL;
+ *
+ **/
+
+// {BoolLiteral} BOOL
+protected class BoolLiteral_Group extends GroupToken {
+
+ public BoolLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getBoolLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new BoolLiteral_BOOLTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {BoolLiteral}
+protected class BoolLiteral_BoolLiteralAction_0 extends ActionToken {
+
+ public BoolLiteral_BoolLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// BOOL
+protected class BoolLiteral_BOOLTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public BoolLiteral_BOOLTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new BoolLiteral_BoolLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule BoolLiteral ****************/
+
+
+/************ begin Rule JSLiteral ****************
+ *
+ * JSLiteral:
+ * {JSLiteral} JS;
+ *
+ **/
+
+// {JSLiteral} JS
+protected class JSLiteral_Group extends GroupToken {
+
+ public JSLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getJSLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new JSLiteral_JSTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {JSLiteral}
+protected class JSLiteral_JSLiteralAction_0 extends ActionToken {
+
+ public JSLiteral_JSLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getJSLiteralAccess().getJSLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// JS
+protected class JSLiteral_JSTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public JSLiteral_JSTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new JSLiteral_JSLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule JSLiteral ****************/
+
+
+/************ begin Rule RegexLiteral ****************
+ *
+ * RegexLiteral:
+ * {RegexLiteral} REGEX;
+ *
+ **/
+
+// {RegexLiteral} REGEX
+protected class RegexLiteral_Group extends GroupToken {
+
+ public RegexLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRegexLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RegexLiteral_REGEXTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {RegexLiteral}
+protected class RegexLiteral_RegexLiteralAction_0 extends ActionToken {
+
+ public RegexLiteral_RegexLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// REGEX
+protected class RegexLiteral_REGEXTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public RegexLiteral_REGEXTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RegexLiteral_RegexLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule RegexLiteral ****************/
+
+
+/************ begin Rule Literal ****************
+ *
+ * Literal:
+ * NumberLiteral | StringLiteral | BoolLiteral | JSLiteral | RegexLiteral;
+ *
+ **/
+
+// NumberLiteral | StringLiteral | BoolLiteral | JSLiteral | RegexLiteral
+protected class Literal_Alternatives extends AlternativesToken {
+
+ public Literal_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Literal_NumberLiteralParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Literal_StringLiteralParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Literal_BoolLiteralParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new Literal_JSLiteralParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
+ case 4: return new Literal_RegexLiteralParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// NumberLiteral
+protected class Literal_NumberLiteralParserRuleCall_0 extends RuleCallToken {
+
+ public Literal_NumberLiteralParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NumberLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(NumberLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// StringLiteral
+protected class Literal_StringLiteralParserRuleCall_1 extends RuleCallToken {
+
+ public Literal_StringLiteralParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new StringLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(StringLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// BoolLiteral
+protected class Literal_BoolLiteralParserRuleCall_2 extends RuleCallToken {
+
+ public Literal_BoolLiteralParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new BoolLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(BoolLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// JSLiteral
+protected class Literal_JSLiteralParserRuleCall_3 extends RuleCallToken {
+
+ public Literal_JSLiteralParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new JSLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(JSLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// RegexLiteral
+protected class Literal_RegexLiteralParserRuleCall_4 extends RuleCallToken {
+
+ public Literal_RegexLiteralParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RegexLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(RegexLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Literal ****************/
+
+
+/************ begin Rule Parenthetical ****************
+ *
+ * Parenthetical:
+ * => (LPAREN INDENT) content=Body OUTDENT RPAREN | LPAREN content=Body RPAREN;
+ *
+ **/
+
+// => (LPAREN INDENT) content=Body OUTDENT RPAREN | LPAREN content=Body RPAREN
+protected class Parenthetical_Alternatives extends AlternativesToken {
+
+ public Parenthetical_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Parenthetical_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getParentheticalRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (LPAREN INDENT) content=Body OUTDENT RPAREN
+protected class Parenthetical_Group_0 extends GroupToken {
+
+ public Parenthetical_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_RPARENTerminalRuleCall_0_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => (LPAREN INDENT)
+protected class Parenthetical_Group_0_0 extends GroupToken {
+
+ public Parenthetical_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_Group_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LPAREN INDENT
+protected class Parenthetical_Group_0_0_0 extends GroupToken {
+
+ public Parenthetical_Group_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getGroup_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_INDENTTerminalRuleCall_0_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LPAREN
+protected class Parenthetical_LPARENTerminalRuleCall_0_0_0_0 extends UnassignedTextToken {
+
+ public Parenthetical_LPARENTerminalRuleCall_0_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// INDENT
+protected class Parenthetical_INDENTTerminalRuleCall_0_0_0_1 extends UnassignedTextToken {
+
+ public Parenthetical_INDENTTerminalRuleCall_0_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_LPARENTerminalRuleCall_0_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+// content=Body
+protected class Parenthetical_ContentAssignment_0_1 extends AssignmentToken {
+
+ public Parenthetical_ContentAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getContentAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("content",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("content");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBodyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Parenthetical_Group_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class Parenthetical_OUTDENTTerminalRuleCall_0_2 extends UnassignedTextToken {
+
+ public Parenthetical_OUTDENTTerminalRuleCall_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_ContentAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// RPAREN
+protected class Parenthetical_RPARENTerminalRuleCall_0_3 extends UnassignedTextToken {
+
+ public Parenthetical_RPARENTerminalRuleCall_0_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_OUTDENTTerminalRuleCall_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+// => LPAREN content=Body RPAREN
+protected class Parenthetical_Group_1 extends GroupToken {
+
+ public Parenthetical_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_RPARENTerminalRuleCall_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => LPAREN
+protected class Parenthetical_LPARENTerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public Parenthetical_LPARENTerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// content=Body
+protected class Parenthetical_ContentAssignment_1_1 extends AssignmentToken {
+
+ public Parenthetical_ContentAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getContentAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("content",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("content");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBodyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Parenthetical_LPARENTerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// RPAREN
+protected class Parenthetical_RPARENTerminalRuleCall_1_2 extends UnassignedTextToken {
+
+ public Parenthetical_RPARENTerminalRuleCall_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_ContentAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+/************ end Rule Parenthetical ****************/
+
+}
diff --git a/csep/src-gen/csep/parser/antlr/CoffeeScriptAntlrTokenFileProvider.java b/csep/src-gen/csep/parser/antlr/CoffeeScriptAntlrTokenFileProvider.java
new file mode 100644
index 0000000..279d35a
--- /dev/null
+++ b/csep/src-gen/csep/parser/antlr/CoffeeScriptAntlrTokenFileProvider.java
@@ -0,0 +1,15 @@
+/*
+* generated by Xtext
+*/
+package csep.parser.antlr;
+
+import java.io.InputStream;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+
+public class CoffeeScriptAntlrTokenFileProvider implements IAntlrTokenFileProvider {
+
+ public InputStream getAntlrTokenFile() {
+ ClassLoader classLoader = getClass().getClassLoader();
+ return classLoader.getResourceAsStream("csep/parser/antlr/internal/InternalCoffeeScript.tokens");
+ }
+}
diff --git a/csep/src-gen/csep/parser/antlr/CoffeeScriptParser.java b/csep/src-gen/csep/parser/antlr/CoffeeScriptParser.java
new file mode 100644
index 0000000..7aee203
--- /dev/null
+++ b/csep/src-gen/csep/parser/antlr/CoffeeScriptParser.java
@@ -0,0 +1,39 @@
+/*
+* generated by Xtext
+*/
+package csep.parser.antlr;
+
+import com.google.inject.Inject;
+
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import csep.services.CoffeeScriptGrammarAccess;
+
+public class CoffeeScriptParser extends org.eclipse.xtext.parser.antlr.AbstractAntlrParser {
+
+ @Inject
+ private CoffeeScriptGrammarAccess grammarAccess;
+
+ @Override
+ protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
+ tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
+ }
+
+ @Override
+ protected csep.parser.antlr.internal.InternalCoffeeScriptParser createParser(XtextTokenStream stream) {
+ return new csep.parser.antlr.internal.InternalCoffeeScriptParser(stream, getGrammarAccess());
+ }
+
+ @Override
+ protected String getDefaultRuleName() {
+ return "Root";
+ }
+
+ public CoffeeScriptGrammarAccess getGrammarAccess() {
+ return this.grammarAccess;
+ }
+
+ public void setGrammarAccess(CoffeeScriptGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+
+}
diff --git a/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g b/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g
new file mode 100644
index 0000000..f79de7b
--- /dev/null
+++ b/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g
@@ -0,0 +1,5557 @@
+/*
+* generated by Xtext
+*/
+grammar InternalCoffeeScript;
+
+options {
+ superClass=AbstractInternalAntlrParser;
+
+}
+
+@lexer::header {
+package csep.parser.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.parser.antlr.Lexer;
+}
+
+@parser::header {
+package csep.parser.antlr.internal;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import csep.services.CoffeeScriptGrammarAccess;
+
+}
+
+@parser::members {
+
+ private CoffeeScriptGrammarAccess grammarAccess;
+
+ public InternalCoffeeScriptParser(TokenStream input, CoffeeScriptGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "Root";
+ }
+
+ @Override
+ protected CoffeeScriptGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+}
+
+@rulecatch {
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+}
+
+
+
+
+// Entry rule entryRuleRoot
+entryRuleRoot returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRootRule()); }
+ iv_ruleRoot=ruleRoot
+ { $current=$iv_ruleRoot.current; }
+ EOF
+;
+
+// Rule Root
+ruleRoot returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getRootAccess().getBodyParserRuleCall_0());
+ }
+ this_Body_0=ruleBody
+ {
+ $current = $this_Body_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |(
+ {
+ newCompositeNode(grammarAccess.getRootAccess().getBlockParserRuleCall_1_0());
+ }
+ this_Block_1=ruleBlock
+ {
+ $current = $this_Block_1.current;
+ afterParserOrEnumRuleCall();
+ }
+this_TERMINATOR_2=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_2, grammarAccess.getRootAccess().getTERMINATORTerminalRuleCall_1_1());
+ }
+))?
+;
+
+
+
+
+
+// Entry rule entryRuleBody
+entryRuleBody returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBodyRule()); }
+ iv_ruleBody=ruleBody
+ { $current=$iv_ruleBody.current; }
+ EOF
+;
+
+// Rule Body
+ruleBody returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0());
+ }
+ lv_lines_0_0=ruleLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBodyRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_0_0,
+ "Line");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_TERMINATOR_1=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0());
+ }
+ lv_lines_2_0=ruleLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBodyRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_2_0,
+ "Line");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)*)
+;
+
+
+
+
+
+// Entry rule entryRuleLine
+entryRuleLine returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLineRule()); }
+ iv_ruleLine=ruleLine
+ { $current=$iv_ruleLine.current; }
+ EOF
+;
+
+// Rule Line
+ruleLine returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getLineAccess().getStmtParserRuleCall_0());
+ }
+ this_Stmt_0=ruleStmt
+ {
+ $current = $this_Stmt_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLineAccess().getExpressionParserRuleCall_1());
+ }
+ this_Expression_1=ruleExpression
+ {
+ $current = $this_Expression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleStmt
+entryRuleStmt returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStmtRule()); }
+ iv_ruleStmt=ruleStmt
+ { $current=$iv_ruleStmt.current; }
+ EOF
+;
+
+// Rule Stmt
+ruleStmt returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0());
+ }
+ this_ReturnStmt_0=ruleReturnStmt
+ {
+ $current = $this_ReturnStmt_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1());
+ }
+ this_ThrowStmt_1=ruleThrowStmt
+ {
+ $current = $this_ThrowStmt_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((((
+(
+ruleId
+)
+) RULE_EQUAL 'require'
+))=>
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2());
+ }
+ this_RequireStmt_2=ruleRequireStmt
+ {
+ $current = $this_RequireStmt_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getCommentParserRuleCall_3());
+ }
+ this_Comment_3=ruleComment
+ {
+ $current = $this_Comment_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4());
+ }
+ this_ClassDeclaration_4=ruleClassDeclaration
+ {
+ $current = $this_ClassDeclaration_4.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |(
+(
+ lv_statement_5_0=RULE_STATEMENT
+ {
+ newLeafNode(lv_statement_5_0, grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getStmtRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "statement",
+ lv_statement_5_0,
+ "STATEMENT");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleComment
+entryRuleComment returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCommentRule()); }
+ iv_ruleComment=ruleComment
+ { $current=$iv_ruleComment.current; }
+ EOF
+;
+
+// Rule Comment
+ruleComment returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ lv_comment_0_0=RULE_HERECOMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getCommentRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "HERECOMMENT");
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleRequireStmt
+entryRuleRequireStmt returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRequireStmtRule()); }
+ iv_ruleRequireStmt=ruleRequireStmt
+ { $current=$iv_ruleRequireStmt.current; }
+ EOF
+;
+
+// Rule RequireStmt
+ruleRequireStmt returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((((
+(
+ruleId
+)
+) RULE_EQUAL 'require'
+))=>((
+(
+ {
+ newCompositeNode(grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0());
+ }
+ lv_importedNamespace_0_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRequireStmtRule());
+ }
+ set(
+ $current,
+ "importedNamespace",
+ lv_importedNamespace_0_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_EQUAL_1=RULE_EQUAL
+ {
+ newLeafNode(this_EQUAL_1, grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1());
+ }
+ otherlv_2='require'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2());
+ }
+))this_CALL_START_3=RULE_CALL_START
+ {
+ newLeafNode(this_CALL_START_3, grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1());
+ }
+(
+(
+ lv_uri_4_0=RULE_STRING
+ {
+ newLeafNode(lv_uri_4_0, grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRequireStmtRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "uri",
+ lv_uri_4_0,
+ "STRING");
+ }
+
+)
+)this_CALL_END_5=RULE_CALL_END
+ {
+ newLeafNode(this_CALL_END_5, grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleReturnStmt
+entryRuleReturnStmt returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getReturnStmtRule()); }
+ iv_ruleReturnStmt=ruleReturnStmt
+ { $current=$iv_ruleReturnStmt.current; }
+ EOF
+;
+
+// Rule ReturnStmt
+ruleReturnStmt returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getReturnStmtAccess().getReturnStmtAction_0(),
+ $current);
+ }
+)this_RETURN_1=RULE_RETURN
+ {
+ newLeafNode(this_RETURN_1, grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0());
+ }
+ lv_expression_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getReturnStmtRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(this_POST_IF_3=RULE_POST_IF
+ {
+ newLeafNode(this_POST_IF_3, grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0());
+ }
+ lv_condition_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getReturnStmtRule());
+ }
+ set(
+ $current,
+ "condition",
+ lv_condition_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleThrowStmt
+entryRuleThrowStmt returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getThrowStmtRule()); }
+ iv_ruleThrowStmt=ruleThrowStmt
+ { $current=$iv_ruleThrowStmt.current; }
+ EOF
+;
+
+// Rule ThrowStmt
+ruleThrowStmt returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(this_THROW_0=RULE_THROW
+ {
+ newLeafNode(this_THROW_0, grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0());
+ }
+ lv_exp_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getThrowStmtRule());
+ }
+ set(
+ $current,
+ "exp",
+ lv_exp_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSuperClass
+entryRuleSuperClass returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSuperClassRule()); }
+ iv_ruleSuperClass=ruleSuperClass
+ { $current=$iv_ruleSuperClass.current; }
+ EOF
+;
+
+// Rule SuperClass
+ruleSuperClass returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0());
+ }
+ this_IdRef_0=ruleIdRef
+ {
+ $current = $this_IdRef_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1());
+ }
+ this_Property_1=ruleProperty
+ {
+ $current = $this_Property_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleClassDeclaration
+entryRuleClassDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassDeclarationRule()); }
+ iv_ruleClassDeclaration=ruleClassDeclaration
+ { $current=$iv_ruleClassDeclaration.current; }
+ EOF
+;
+
+// Rule ClassDeclaration
+ruleClassDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0(),
+ $current);
+ }
+)this_CLASS_1=RULE_CLASS
+ {
+ newLeafNode(this_CLASS_1, grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0());
+ }
+ lv_body_2_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(this_EXTENDS_3=RULE_EXTENDS
+ {
+ newLeafNode(this_EXTENDS_3, grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0());
+ }
+ lv_extend_4_0=ruleSuperClass {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "extend",
+ lv_extend_4_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+ }
+ lv_body_5_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_5_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+ |((
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0());
+ }
+ lv_name_6_1=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_6_1,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+ | {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1());
+ }
+ lv_name_6_2=ruleProperty {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_6_2,
+ "Property");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+
+)
+)(this_EXTENDS_7=RULE_EXTENDS
+ {
+ newLeafNode(this_EXTENDS_7, grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0());
+ }
+ lv_extend_8_0=ruleSuperClass {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "extend",
+ lv_extend_8_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0());
+ }
+ lv_body_9_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_9_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignedClassDeclaration
+entryRuleAssignedClassDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignedClassDeclarationRule()); }
+ iv_ruleAssignedClassDeclaration=ruleAssignedClassDeclaration
+ { $current=$iv_ruleAssignedClassDeclaration.current; }
+ EOF
+;
+
+// Rule AssignedClassDeclaration
+ruleAssignedClassDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0(),
+ $current);
+ }
+)this_CLASS_1=RULE_CLASS
+ {
+ newLeafNode(this_CLASS_1, grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+ }
+((this_EXTENDS_2=RULE_EXTENDS
+ {
+ newLeafNode(this_EXTENDS_2, grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0());
+ }
+ lv_extend_3_0=ruleSuperClass {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "extend",
+ lv_extend_3_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0());
+ }
+ lv_body_4_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0());
+ }
+ lv_name_5_1=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_5_1,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+ | {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1());
+ }
+ lv_name_5_2=ruleProperty {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_5_2,
+ "Property");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+
+)
+)(this_EXTENDS_6=RULE_EXTENDS
+ {
+ newLeafNode(this_EXTENDS_6, grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0());
+ }
+ lv_extend_7_0=ruleSuperClass {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "extend",
+ lv_extend_7_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+ }
+ lv_body_8_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_8_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleExpression
+entryRuleExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExpressionRule()); }
+ iv_ruleExpression=ruleExpression
+ { $current=$iv_ruleExpression.current; }
+ EOF
+;
+
+// Rule Expression
+ruleExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ {
+ newCompositeNode(grammarAccess.getExpressionAccess().getPostfixParserRuleCall());
+ }
+ this_Postfix_0=rulePostfix
+ {
+ $current = $this_Postfix_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+;
+
+
+
+
+
+// Entry rule entryRulePostfix
+entryRulePostfix returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPostfixRule()); }
+ iv_rulePostfix=rulePostfix
+ { $current=$iv_rulePostfix.current; }
+ EOF
+;
+
+// Rule Postfix
+rulePostfix returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0());
+ }
+ this_Assignment_0=ruleAssignment
+ {
+ $current = $this_Assignment_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((( RULE_POST_IF)=>this_POST_IF_1=RULE_POST_IF
+ {
+ newLeafNode(this_POST_IF_1, grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0());
+ }
+)(
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0());
+ }
+ lv_condition_3_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "condition",
+ lv_condition_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((( RULE_FOR)=>this_FOR_4=RULE_FOR
+ {
+ newLeafNode(this_FOR_4, grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0());
+ }
+)(
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getForDummyAction_1_1_1(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0());
+ }
+ lv_body_6_0=ruleForBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_6_0,
+ "ForBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((( RULE_WHILE)=>this_WHILE_7=RULE_WHILE
+ {
+ newLeafNode(this_WHILE_7, grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0());
+ }
+)(
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0());
+ }
+ lv_body_9_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_9_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_WHEN)=>this_WHEN_10=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_10, grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0());
+ }
+ lv_when_11_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_11_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |((( RULE_UNTIL)=>this_UNTIL_12=RULE_UNTIL
+ {
+ newLeafNode(this_UNTIL_12, grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0());
+ }
+)(
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0());
+ }
+ lv_body_14_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_14_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_WHEN)=>this_WHEN_15=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_15, grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0());
+ }
+ lv_when_16_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_16_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?))?)
+;
+
+
+
+
+
+// Entry rule entryRuleForBody
+entryRuleForBody returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getForBodyRule()); }
+ iv_ruleForBody=ruleForBody
+ { $current=$iv_ruleForBody.current; }
+ EOF
+;
+
+// Rule ForBody
+ruleForBody returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((this_OWN_0=RULE_OWN
+ {
+ newLeafNode(this_OWN_0, grammarAccess.getForBodyAccess().getOWNTerminalRuleCall_0());
+ }
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0());
+ }
+ lv_indexes_1_0=ruleForValue {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ add(
+ $current,
+ "indexes",
+ lv_indexes_1_0,
+ "ForValue");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_2=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_2, grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0());
+ }
+ lv_indexes_3_0=ruleForValue {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ add(
+ $current,
+ "indexes",
+ lv_indexes_3_0,
+ "ForValue");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(
+(
+ {
+ newCompositeNode(grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0());
+ }
+ lv_source_4_0=ruleForSource {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_4_0,
+ "ForSource");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleForValue
+entryRuleForValue returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getForValueRule()); }
+ iv_ruleForValue=ruleForValue
+ { $current=$iv_ruleForValue.current; }
+ EOF
+;
+
+// Rule ForValue
+ruleForValue returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ {
+ newCompositeNode(grammarAccess.getForValueAccess().getIdParserRuleCall());
+ }
+ this_Id_0=ruleId
+ {
+ $current = $this_Id_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+;
+
+
+
+
+
+// Entry rule entryRuleForSource
+entryRuleForSource returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getForSourceRule()); }
+ iv_ruleForSource=ruleForSource
+ { $current=$iv_ruleForSource.current; }
+ EOF
+;
+
+// Rule ForSource
+ruleForSource returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getForSourceAccess().getForSourceAction_0(),
+ $current);
+ }
+)(((( RULE_FOROF)=>this_FOROF_1=RULE_FOROF
+ {
+ newLeafNode(this_FOROF_1, grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0());
+ }
+ lv_source_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_WHEN)=>this_WHEN_3=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_3, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0());
+ }
+ lv_when_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |((( RULE_FORIN)=>this_FORIN_5=RULE_FORIN
+ {
+ newLeafNode(this_FORIN_5, grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0());
+ }
+ lv_source_6_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_6_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(((( RULE_WHEN)=>this_WHEN_7=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_7, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0());
+ }
+ lv_when_8_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_8_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_BY)=>this_BY_9=RULE_BY
+ {
+ newLeafNode(this_BY_9, grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0());
+ }
+ lv_by_10_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "by",
+ lv_by_10_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |((( RULE_BY)=>this_BY_11=RULE_BY
+ {
+ newLeafNode(this_BY_11, grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0());
+ }
+ lv_by_12_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "by",
+ lv_by_12_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_WHEN)=>this_WHEN_13=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_13, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0());
+ }
+ lv_when_14_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_14_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?))?)))
+;
+
+
+
+
+
+// Entry rule entryRuleRange
+entryRuleRange returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRangeRule()); }
+ iv_ruleRange=ruleRange
+ { $current=$iv_ruleRange.current; }
+ EOF
+;
+
+// Rule Range
+ruleRange returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((( RULE_LBRACKET(
+(
+ruleExpression
+)
+)( RULE_DOT_DOT
+ | RULE_ELLIPSIS)))=>(this_LBRACKET_0=RULE_LBRACKET
+ {
+ newLeafNode(this_LBRACKET_0, grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0());
+ }
+ lv_start_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRangeRule());
+ }
+ set(
+ $current,
+ "start",
+ lv_start_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_DOT_DOT_2=RULE_DOT_DOT
+ {
+ newLeafNode(this_DOT_DOT_2, grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0());
+ }
+
+ |this_ELLIPSIS_3=RULE_ELLIPSIS
+ {
+ newLeafNode(this_ELLIPSIS_3, grammarAccess.getRangeAccess().getELLIPSISTerminalRuleCall_0_0_2_1());
+ }
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0());
+ }
+ lv_end_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRangeRule());
+ }
+ set(
+ $current,
+ "end",
+ lv_end_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_RBRACKET_5=RULE_RBRACKET
+ {
+ newLeafNode(this_RBRACKET_5, grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignment
+entryRuleAssignment returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignmentRule()); }
+ iv_ruleAssignment=ruleAssignment
+ { $current=$iv_ruleAssignment.current; }
+ EOF
+;
+
+// Rule Assignment
+ruleAssignment returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((((
+(
+ruleAssignable
+)
+)(
+(
+(
+RULE_EQUAL
+
+ | RULE_COMPOUND_ASSIGN
+
+)
+
+)
+)))=>((
+(
+ {
+ newCompositeNode(grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0());
+ }
+ lv_left_0_0=ruleAssignable {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignmentRule());
+ }
+ set(
+ $current,
+ "left",
+ lv_left_0_0,
+ "Assignable");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+(
+ lv_operator_1_1=RULE_EQUAL
+ {
+ newLeafNode(lv_operator_1_1, grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAssignmentRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_1_1,
+ "EQUAL");
+ }
+
+ | lv_operator_1_2=RULE_COMPOUND_ASSIGN
+ {
+ newLeafNode(lv_operator_1_2, grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAssignmentRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_1_2,
+ "COMPOUND_ASSIGN");
+ }
+
+)
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0());
+ }
+ lv_right_2_0=ruleAssigned {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignmentRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_2_0,
+ "Assigned");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |
+ {
+ newCompositeNode(grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1());
+ }
+ this_LogicOp_3=ruleLogicOp
+ {
+ $current = $this_LogicOp_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAssigned
+entryRuleAssigned returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignedRule()); }
+ iv_ruleAssigned=ruleAssigned
+ { $current=$iv_ruleAssigned.current; }
+ EOF
+;
+
+// Rule Assigned
+ruleAssigned returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0());
+ }
+ this_Expression_0=ruleExpression
+ {
+ $current = $this_Expression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |(this_INDENT_1=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_1, grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0());
+ }
+
+ {
+ newCompositeNode(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1());
+ }
+ this_Expression_2=ruleExpression
+ {
+ $current = $this_Expression_2.current;
+ afterParserOrEnumRuleCall();
+ }
+this_OUTDENT_3=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_3, grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2());
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2());
+ }
+ this_AssignedClassDeclaration_4=ruleAssignedClassDeclaration
+ {
+ $current = $this_AssignedClassDeclaration_4.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleLogicOp
+entryRuleLogicOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLogicOpRule()); }
+ iv_ruleLogicOp=ruleLogicOp
+ { $current=$iv_ruleLogicOp.current; }
+ EOF
+;
+
+// Rule LogicOp
+ruleLogicOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0());
+ }
+ this_CompareOp_0=ruleCompareOp
+ {
+ $current = $this_CompareOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_LOGIC
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_LOGIC
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getLogicOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "LOGIC");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleCompareOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLogicOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "CompareOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleCompareOp
+entryRuleCompareOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCompareOpRule()); }
+ iv_ruleCompareOp=ruleCompareOp
+ { $current=$iv_ruleCompareOp.current; }
+ EOF
+;
+
+// Rule CompareOp
+ruleCompareOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0());
+ }
+ this_RelationOp_0=ruleRelationOp
+ {
+ $current = $this_RelationOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_COMPARE
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_COMPARE
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getCompareOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "COMPARE");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleRelationOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCompareOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "RelationOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleRelationOp
+entryRuleRelationOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRelationOpRule()); }
+ iv_ruleRelationOp=ruleRelationOp
+ { $current=$iv_ruleRelationOp.current; }
+ EOF
+;
+
+// Rule RelationOp
+ruleRelationOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0());
+ }
+ this_ShiftOp_0=ruleShiftOp
+ {
+ $current = $this_ShiftOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_RELATION
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_RELATION
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRelationOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "RELATION");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleShiftOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRelationOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "ShiftOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleShiftOp
+entryRuleShiftOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getShiftOpRule()); }
+ iv_ruleShiftOp=ruleShiftOp
+ { $current=$iv_ruleShiftOp.current; }
+ EOF
+;
+
+// Rule ShiftOp
+ruleShiftOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0());
+ }
+ this_AdditiveOp_0=ruleAdditiveOp
+ {
+ $current = $this_AdditiveOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_SHIFT
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_SHIFT
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getShiftOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "SHIFT");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleAdditiveOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getShiftOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "AdditiveOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleAdditiveOp
+entryRuleAdditiveOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAdditiveOpRule()); }
+ iv_ruleAdditiveOp=ruleAdditiveOp
+ { $current=$iv_ruleAdditiveOp.current; }
+ EOF
+;
+
+// Rule AdditiveOp
+ruleAdditiveOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0());
+ }
+ this_MathOp_0=ruleMathOp
+ {
+ $current = $this_MathOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+(
+RULE_PLUS
+
+ | RULE_MINUS
+
+)
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+(
+ lv_operator_2_1=RULE_PLUS
+ {
+ newLeafNode(lv_operator_2_1, grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAdditiveOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_1,
+ "PLUS");
+ }
+
+ | lv_operator_2_2=RULE_MINUS
+ {
+ newLeafNode(lv_operator_2_2, grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAdditiveOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_2,
+ "MINUS");
+ }
+
+)
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleMathOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAdditiveOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "MathOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleMathOp
+entryRuleMathOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getMathOpRule()); }
+ iv_ruleMathOp=ruleMathOp
+ { $current=$iv_ruleMathOp.current; }
+ EOF
+;
+
+// Rule MathOp
+ruleMathOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0());
+ }
+ this_UnaryOp_0=ruleUnaryOp
+ {
+ $current = $this_UnaryOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_MATH
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_MATH
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getMathOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "MATH");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleUnaryOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMathOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "UnaryOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleUnaryOp
+entryRuleUnaryOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getUnaryOpRule()); }
+ iv_ruleUnaryOp=ruleUnaryOp
+ { $current=$iv_ruleUnaryOp.current; }
+ EOF
+;
+
+// Rule UnaryOp
+ruleUnaryOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((this_UNARY_0=RULE_UNARY
+ {
+ newLeafNode(this_UNARY_0, grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0());
+ }
+
+ |this_PLUS_1=RULE_PLUS
+ {
+ newLeafNode(this_PLUS_1, grammarAccess.getUnaryOpAccess().getPLUSTerminalRuleCall_0_0_1());
+ }
+
+ |this_MINUS_2=RULE_MINUS
+ {
+ newLeafNode(this_MINUS_2, grammarAccess.getUnaryOpAccess().getMINUSTerminalRuleCall_0_0_2());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1());
+ }
+ this_Expression_3=ruleExpression
+ {
+ $current = $this_Expression_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |((this_PLUS_PLUS_4=RULE_PLUS_PLUS
+ {
+ newLeafNode(this_PLUS_PLUS_4, grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0());
+ }
+
+ |this_MINUS_MINUS_5=RULE_MINUS_MINUS
+ {
+ newLeafNode(this_MINUS_MINUS_5, grammarAccess.getUnaryOpAccess().getMINUS_MINUSTerminalRuleCall_1_0_1());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1());
+ }
+ this_Variable_6=ruleVariable
+ {
+ $current = $this_Variable_6.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(
+ {
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0());
+ }
+ this_Application_7=ruleApplication
+ {
+ $current = $this_Application_7.current;
+ afterParserOrEnumRuleCall();
+ }
+(this_QUESTION_8=RULE_QUESTION
+ {
+ newLeafNode(this_QUESTION_8, grammarAccess.getUnaryOpAccess().getQUESTIONTerminalRuleCall_2_1());
+ }
+)?))
+;
+
+
+
+
+
+// Entry rule entryRuleApplication
+entryRuleApplication returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getApplicationRule()); }
+ iv_ruleApplication=ruleApplication
+ { $current=$iv_ruleApplication.current; }
+ EOF
+;
+
+// Rule Application
+ruleApplication returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getApplicationAccess().getSuperCallAction_0_0(),
+ $current);
+ }
+)(this_SUPER_1=RULE_SUPER
+ {
+ newLeafNode(this_SUPER_1, grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0());
+ }
+(this_CALL_START_2=RULE_CALL_START
+ {
+ newLeafNode(this_CALL_START_2, grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0());
+ }
+ lv_args_3_0=ruleArgList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ set(
+ $current,
+ "args",
+ lv_args_3_0,
+ "ArgList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_CALL_END_4=RULE_CALL_END
+ {
+ newLeafNode(this_CALL_END_4, grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2());
+ }
+)?))
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0());
+ }
+ lv_value_5_0=rulePrimaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_5_0,
+ "PrimaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0());
+ }
+ lv_features_6_0=ruleFeatureCall {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ add(
+ $current,
+ "features",
+ lv_features_6_0,
+ "FeatureCall");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*))
+;
+
+
+
+
+
+// Entry rule entryRuleFeatureCall
+entryRuleFeatureCall returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFeatureCallRule()); }
+ iv_ruleFeatureCall=ruleFeatureCall
+ { $current=$iv_ruleFeatureCall.current; }
+ EOF
+;
+
+// Rule FeatureCall
+ruleFeatureCall returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0());
+ }
+ this_FunctionCall_0=ruleFunctionCall
+ {
+ $current = $this_FunctionCall_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1());
+ }
+ this_PropertyAccess_1=rulePropertyAccess
+ {
+ $current = $this_PropertyAccess_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleFunctionCall
+entryRuleFunctionCall returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFunctionCallRule()); }
+ iv_ruleFunctionCall=ruleFunctionCall
+ { $current=$iv_ruleFunctionCall.current; }
+ EOF
+;
+
+// Rule FunctionCall
+ruleFunctionCall returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getFunctionCallAccess().getFunctionCallAction_0(),
+ $current);
+ }
+)(this_FUNC_EXIST_1=RULE_FUNC_EXIST
+ {
+ newLeafNode(this_FUNC_EXIST_1, grammarAccess.getFunctionCallAccess().getFUNC_EXISTTerminalRuleCall_1());
+ }
+)?this_CALL_START_2=RULE_CALL_START
+ {
+ newLeafNode(this_CALL_START_2, grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0());
+ }
+ lv_args_3_0=ruleArgList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFunctionCallRule());
+ }
+ set(
+ $current,
+ "args",
+ lv_args_3_0,
+ "ArgList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_CALL_END_4=RULE_CALL_END
+ {
+ newLeafNode(this_CALL_END_4, grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePropertyAccess
+entryRulePropertyAccess returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyAccessRule()); }
+ iv_rulePropertyAccess=rulePropertyAccess
+ { $current=$iv_rulePropertyAccess.current; }
+ EOF
+;
+
+// Rule PropertyAccess
+rulePropertyAccess returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0());
+ }
+ this_NamedPropertyAccess_0=ruleNamedPropertyAccess
+ {
+ $current = $this_NamedPropertyAccess_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1());
+ }
+ this_IndexedPropertyAccess_1=ruleIndexedPropertyAccess
+ {
+ $current = $this_IndexedPropertyAccess_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleThisProperty
+entryRuleThisProperty returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getThisPropertyRule()); }
+ iv_ruleThisProperty=ruleThisProperty
+ { $current=$iv_ruleThisProperty.current; }
+ EOF
+;
+
+// Rule ThisProperty
+ruleThisProperty returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(this_AT_SIGIL_0=RULE_AT_SIGIL
+ {
+ newLeafNode(this_AT_SIGIL_0, grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0());
+ }
+
+ {
+ newCompositeNode(grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1());
+ }
+ this_Id_1=ruleId
+ {
+ $current = $this_Id_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleNamedPropertyAccess
+entryRuleNamedPropertyAccess returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNamedPropertyAccessRule()); }
+ iv_ruleNamedPropertyAccess=ruleNamedPropertyAccess
+ { $current=$iv_ruleNamedPropertyAccess.current; }
+ EOF
+;
+
+// Rule NamedPropertyAccess
+ruleNamedPropertyAccess returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+(
+ lv_accessor_0_1=RULE_DOT
+ {
+ newLeafNode(lv_accessor_0_1, grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_0_1,
+ "DOT");
+ }
+
+ | lv_accessor_0_2=RULE_QUESTION_DOT
+ {
+ newLeafNode(lv_accessor_0_2, grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_0_2,
+ "QUESTION_DOT");
+ }
+
+)
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0());
+ }
+ lv_name_1_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedPropertyAccessRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((
+(
+ lv_accessor_2_0=RULE_DOUBLE_COLON
+ {
+ newLeafNode(lv_accessor_2_0, grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_2_0,
+ "DOUBLE_COLON");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0());
+ }
+ lv_name_3_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedPropertyAccessRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_3_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?))
+;
+
+
+
+
+
+// Entry rule entryRuleIndexedPropertyAccess
+entryRuleIndexedPropertyAccess returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIndexedPropertyAccessRule()); }
+ iv_ruleIndexedPropertyAccess=ruleIndexedPropertyAccess
+ { $current=$iv_ruleIndexedPropertyAccess.current; }
+ EOF
+;
+
+// Rule IndexedPropertyAccess
+ruleIndexedPropertyAccess returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(this_INDEX_START_0=RULE_INDEX_START
+ {
+ newLeafNode(this_INDEX_START_0, grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0());
+ }
+ lv_index_1_0=ruleIndex {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexedPropertyAccessRule());
+ }
+ set(
+ $current,
+ "index",
+ lv_index_1_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_INDEX_END_2=RULE_INDEX_END
+ {
+ newLeafNode(this_INDEX_END_2, grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleIndex
+entryRuleIndex returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIndexRule()); }
+ iv_ruleIndex=ruleIndex
+ { $current=$iv_ruleIndex.current; }
+ EOF
+;
+
+// Rule Index
+ruleIndex returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((
+(
+(
+RULE_DOT_DOT
+
+ | RULE_ELLIPSIS
+
+)
+
+)
+)=>
+(
+(
+ lv_dots_0_1=RULE_DOT_DOT
+ {
+ newLeafNode(lv_dots_0_1, grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "dots",
+ lv_dots_0_1,
+ "DOT_DOT");
+ }
+
+ | lv_dots_0_2=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_dots_0_2, grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "dots",
+ lv_dots_0_2,
+ "ELLIPSIS");
+ }
+
+)
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0());
+ }
+ lv_end_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ $current,
+ "end",
+ lv_end_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(((((
+(
+ruleExpression
+)
+)(
+(
+(
+RULE_DOT_DOT
+
+ | RULE_ELLIPSIS
+
+)
+
+)
+)))=>((
+(
+ {
+ newCompositeNode(grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0());
+ }
+ lv_start_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ $current,
+ "start",
+ lv_start_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+(
+ lv_dots_3_1=RULE_DOT_DOT
+ {
+ newLeafNode(lv_dots_3_1, grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "dots",
+ lv_dots_3_1,
+ "DOT_DOT");
+ }
+
+ | lv_dots_3_2=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_dots_3_2, grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "dots",
+ lv_dots_3_2,
+ "ELLIPSIS");
+ }
+
+)
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0());
+ }
+ lv_end_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ $current,
+ "end",
+ lv_end_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0());
+ }
+ lv_exp_5_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ $current,
+ "exp",
+ lv_exp_5_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePrimaryExpression
+entryRulePrimaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPrimaryExpressionRule()); }
+ iv_rulePrimaryExpression=rulePrimaryExpression
+ { $current=$iv_rulePrimaryExpression.current; }
+ EOF
+;
+
+// Rule PrimaryExpression
+rulePrimaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0());
+ }
+ this_IfExp_0=ruleIfExp
+ {
+ $current = $this_IfExp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1());
+ }
+ this_Parenthetical_1=ruleParenthetical
+ {
+ $current = $this_Parenthetical_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2());
+ }
+ this_Literal_2=ruleLiteral
+ {
+ $current = $this_Literal_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((( RULE_LBRACKET(
+(
+ruleExpression
+)
+)( RULE_DOT_DOT
+ | RULE_ELLIPSIS)))=>
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3());
+ }
+ this_Range_3=ruleRange
+ {
+ $current = $this_Range_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(( RULE_LBRACKET)=>
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4());
+ }
+ this_Array_4=ruleArray
+ {
+ $current = $this_Array_4.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(( RULE_LCURLY)=>
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5());
+ }
+ this_Dictionary_5=ruleDictionary
+ {
+ $current = $this_Dictionary_5.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6());
+ }
+ this_Lambda_6=ruleLambda
+ {
+ $current = $this_Lambda_6.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7());
+ }
+ this_ThisProperty_7=ruleThisProperty
+ {
+ $current = $this_ThisProperty_7.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0(),
+ $current);
+ }
+)this_THIS_9=RULE_THIS
+ {
+ newLeafNode(this_THIS_9, grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1());
+ }
+)
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getForAction_9_0(),
+ $current);
+ }
+)(this_FOR_11=RULE_FOR
+ {
+ newLeafNode(this_FOR_11, grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0());
+ }
+ lv_loop_12_0=ruleForBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "loop",
+ lv_loop_12_0,
+ "ForBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0());
+ }
+ lv_body_13_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_13_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0(),
+ $current);
+ }
+)(this_WHILE_15=RULE_WHILE
+ {
+ newLeafNode(this_WHILE_15, grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0());
+ }
+ lv_loop_16_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "loop",
+ lv_loop_16_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_WHEN_17=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_17, grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0());
+ }
+ lv_when_18_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_18_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0());
+ }
+ lv_body_19_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_19_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0(),
+ $current);
+ }
+)(this_UNTIL_21=RULE_UNTIL
+ {
+ newLeafNode(this_UNTIL_21, grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0());
+ }
+ lv_loop_22_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "loop",
+ lv_loop_22_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_WHEN_23=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_23, grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0());
+ }
+ lv_when_24_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_24_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0());
+ }
+ lv_body_25_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_25_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0(),
+ $current);
+ }
+)(this_LOOP_27=RULE_LOOP
+ {
+ newLeafNode(this_LOOP_27, grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0());
+ }
+ lv_body_28_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_28_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0(),
+ $current);
+ }
+)(this_TRY_30=RULE_TRY
+ {
+ newLeafNode(this_TRY_30, grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0());
+ }
+ lv_body_31_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_31_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((this_CATCH_32=RULE_CATCH
+ {
+ newLeafNode(this_CATCH_32, grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0());
+ }
+ lv_exception_33_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "exception",
+ lv_exception_33_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0());
+ }
+ lv_catchBlock_34_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "catchBlock",
+ lv_catchBlock_34_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_FINALLY_35=RULE_FINALLY
+ {
+ newLeafNode(this_FINALLY_35, grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0());
+ }
+ lv_finallyBlock_36_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "finallyBlock",
+ lv_finallyBlock_36_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |(this_FINALLY_37=RULE_FINALLY
+ {
+ newLeafNode(this_FINALLY_37, grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0());
+ }
+ lv_finallyBlock_38_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "finallyBlock",
+ lv_finallyBlock_38_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))?))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0(),
+ $current);
+ }
+)(this_SWITCH_40=RULE_SWITCH
+ {
+ newLeafNode(this_SWITCH_40, grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0());
+ }
+ lv_exp_41_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "exp",
+ lv_exp_41_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?this_INDENT_42=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_42, grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0());
+ }
+ lv_cases_43_0=ruleCase {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ add(
+ $current,
+ "cases",
+ lv_cases_43_0,
+ "Case");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*(this_ELSE_44=RULE_ELSE
+ {
+ newLeafNode(this_ELSE_44, grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0());
+ }
+ lv_elseBlock_45_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "elseBlock",
+ lv_elseBlock_45_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?this_OUTDENT_46=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_46, grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5());
+ }
+))
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15());
+ }
+ this_IdRef_47=ruleIdRef
+ {
+ $current = $this_IdRef_47.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleBlock
+entryRuleBlock returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBlockRule()); }
+ iv_ruleBlock=ruleBlock
+ { $current=$iv_ruleBlock.current; }
+ EOF
+;
+
+// Rule Block
+ruleBlock returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getBlockAccess().getBlockAction_0(),
+ $current);
+ }
+)this_INDENT_1=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_1, grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1());
+ }
+(
+ {
+ newCompositeNode(grammarAccess.getBlockAccess().getBodyParserRuleCall_2());
+ }
+ this_Body_2=ruleBody
+ {
+ $current = $this_Body_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)?this_OUTDENT_3=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_3, grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleCase
+entryRuleCase returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCaseRule()); }
+ iv_ruleCase=ruleCase
+ { $current=$iv_ruleCase.current; }
+ EOF
+;
+
+// Rule Case
+ruleCase returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(this_LEADING_WHEN_0=RULE_LEADING_WHEN
+ {
+ newLeafNode(this_LEADING_WHEN_0, grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0());
+ }
+ lv_whens_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ add(
+ $current,
+ "whens",
+ lv_whens_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_2=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_2, grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0());
+ }
+ lv_whens_3_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ add(
+ $current,
+ "whens",
+ lv_whens_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(
+(
+ {
+ newCompositeNode(grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0());
+ }
+ lv_then_4_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ set(
+ $current,
+ "then",
+ lv_then_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_TERMINATOR_5=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_5, grammarAccess.getCaseAccess().getTERMINATORTerminalRuleCall_4());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleIfExp
+entryRuleIfExp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIfExpRule()); }
+ iv_ruleIfExp=ruleIfExp
+ { $current=$iv_ruleIfExp.current; }
+ EOF
+;
+
+// Rule IfExp
+ruleIfExp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0());
+ }
+ lv_blocks_0_0=ruleCondBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ add(
+ $current,
+ "blocks",
+ lv_blocks_0_0,
+ "CondBlock");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_ELSE_1=RULE_ELSE
+ {
+ newLeafNode(this_ELSE_1, grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0());
+ }
+ lv_blocks_2_0=ruleCondBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ add(
+ $current,
+ "blocks",
+ lv_blocks_2_0,
+ "CondBlock");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(this_ELSE_3=RULE_ELSE
+ {
+ newLeafNode(this_ELSE_3, grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0());
+ }
+ lv_defaultBlock_4_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ set(
+ $current,
+ "defaultBlock",
+ lv_defaultBlock_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleCondBlock
+entryRuleCondBlock returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCondBlockRule()); }
+ iv_ruleCondBlock=ruleCondBlock
+ { $current=$iv_ruleCondBlock.current; }
+ EOF
+;
+
+// Rule CondBlock
+ruleCondBlock returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_operator_0_0=RULE_IF
+ {
+ newLeafNode(lv_operator_0_0, grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getCondBlockRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_0_0,
+ "IF");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0());
+ }
+ lv_condition_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCondBlockRule());
+ }
+ set(
+ $current,
+ "condition",
+ lv_condition_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0());
+ }
+ lv_action_2_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCondBlockRule());
+ }
+ set(
+ $current,
+ "action",
+ lv_action_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleIdRef
+entryRuleIdRef returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIdRefRule()); }
+ iv_ruleIdRef=ruleIdRef
+ { $current=$iv_ruleIdRef.current; }
+ EOF
+;
+
+// Rule IdRef
+ruleIdRef returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIdRefRule());
+ }
+ }
+ otherlv_0=RULE_IDENTIFIER
+ {
+ newLeafNode(otherlv_0, grammarAccess.getIdRefAccess().getValIdCrossReference_0());
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleId
+entryRuleId returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIdRule()); }
+ iv_ruleId=ruleId
+ { $current=$iv_ruleId.current; }
+ EOF
+;
+
+// Rule Id
+ruleId returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ lv_name_0_0=RULE_IDENTIFIER
+ {
+ newLeafNode(lv_name_0_0, grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIdRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "name",
+ lv_name_0_0,
+ "IDENTIFIER");
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleProperty
+entryRuleProperty returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyRule()); }
+ iv_ruleProperty=ruleProperty
+ { $current=$iv_ruleProperty.current; }
+ EOF
+;
+
+// Rule Property
+ruleProperty returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((( ruleIdRef(
+(
+(
+RULE_DOT
+
+ | RULE_DOUBLE_COLON
+
+ | RULE_QUESTION_DOT
+
+)
+
+)
+)))=>(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0());
+ }
+ this_IdRef_0=ruleIdRef
+ {
+ $current = $this_IdRef_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(
+(
+(
+ lv_accessor_1_1=RULE_DOT
+ {
+ newLeafNode(lv_accessor_1_1, grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_1_1,
+ "DOT");
+ }
+
+ | lv_accessor_1_2=RULE_DOUBLE_COLON
+ {
+ newLeafNode(lv_accessor_1_2, grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_1_2,
+ "DOUBLE_COLON");
+ }
+
+ | lv_accessor_1_3=RULE_QUESTION_DOT
+ {
+ newLeafNode(lv_accessor_1_3, grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_1_3,
+ "QUESTION_DOT");
+ }
+
+)
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0());
+ }
+ lv_prop_2_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ $current,
+ "prop",
+ lv_prop_2_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(((( ruleIdRef RULE_INDEX_START))=>(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0());
+ }
+ this_IdRef_3=ruleIdRef
+ {
+ $current = $this_IdRef_3.current;
+ afterParserOrEnumRuleCall();
+ }
+this_INDEX_START_4=RULE_INDEX_START
+ {
+ newLeafNode(this_INDEX_START_4, grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1());
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0());
+ }
+ lv_index_5_0=ruleIndex {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ $current,
+ "index",
+ lv_index_5_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_INDEX_END_6=RULE_INDEX_END
+ {
+ newLeafNode(this_INDEX_END_6, grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2());
+ }
+))
+;
+
+
+
+
+
+// Entry rule entryRuleVariable
+entryRuleVariable returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getVariableRule()); }
+ iv_ruleVariable=ruleVariable
+ { $current=$iv_ruleVariable.current; }
+ EOF
+;
+
+// Rule Variable
+ruleVariable returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getVariableAccess().getIdParserRuleCall_0());
+ }
+ this_Id_0=ruleId
+ {
+ $current = $this_Id_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((this_AT_SIGIL_1=RULE_AT_SIGIL
+ {
+ newLeafNode(this_AT_SIGIL_1, grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0());
+ }
+
+ |(this_THIS_2=RULE_THIS
+ {
+ newLeafNode(this_THIS_2, grammarAccess.getVariableAccess().getTHISTerminalRuleCall_1_0_1_0());
+ }
+this_DOT_3=RULE_DOT
+ {
+ newLeafNode(this_DOT_3, grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_0_1_1());
+ }
+))
+ {
+ newCompositeNode(grammarAccess.getVariableAccess().getIdParserRuleCall_1_1());
+ }
+ this_Id_4=ruleId
+ {
+ $current = $this_Id_4.current;
+ afterParserOrEnumRuleCall();
+ }
+(this_DOT_5=RULE_DOT
+ {
+ newLeafNode(this_DOT_5, grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0());
+ }
+ lv_props_6_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getVariableRule());
+ }
+ add(
+ $current,
+ "props",
+ lv_props_6_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+ |
+ {
+ newCompositeNode(grammarAccess.getVariableAccess().getPropertyParserRuleCall_2());
+ }
+ this_Property_7=ruleProperty
+ {
+ $current = $this_Property_7.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignableArray
+entryRuleAssignableArray returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignableArrayRule()); }
+ iv_ruleAssignableArray=ruleAssignableArray
+ { $current=$iv_ruleAssignableArray.current; }
+ EOF
+;
+
+// Rule AssignableArray
+ruleAssignableArray returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((( RULE_LBRACKET)=>this_LBRACKET_0=RULE_LBRACKET
+ {
+ newLeafNode(this_LBRACKET_0, grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1());
+ }
+ this_AssignableArgList_1=ruleAssignableArgList
+ {
+ $current = $this_AssignableArgList_1.current;
+ afterParserOrEnumRuleCall();
+ }
+this_RBRACKET_2=RULE_RBRACKET
+ {
+ newLeafNode(this_RBRACKET_2, grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignableArgList
+entryRuleAssignableArgList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignableArgListRule()); }
+ iv_ruleAssignableArgList=ruleAssignableArgList
+ { $current=$iv_ruleAssignableArgList.current; }
+ EOF
+;
+
+// Rule AssignableArgList
+ruleAssignableArgList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0());
+ }
+ lv_args_0_0=ruleAssignableArg {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignableArgListRule());
+ }
+ add(
+ $current,
+ "args",
+ lv_args_0_0,
+ "AssignableArg");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_1=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_1, grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0());
+ }
+ lv_args_2_0=ruleAssignableArg {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignableArgListRule());
+ }
+ add(
+ $current,
+ "args",
+ lv_args_2_0,
+ "AssignableArg");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignableArg
+entryRuleAssignableArg returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignableArgRule()); }
+ iv_ruleAssignableArg=ruleAssignableArg
+ { $current=$iv_ruleAssignableArg.current; }
+ EOF
+;
+
+// Rule AssignableArg
+ruleAssignableArg returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0());
+ }
+ lv_arg_0_0=ruleAssignable {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignableArgRule());
+ }
+ set(
+ $current,
+ "arg",
+ lv_arg_0_0,
+ "Assignable");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ lv_splat_1_0=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_splat_1_0, grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAssignableArgRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "splat",
+ true,
+ "ELLIPSIS");
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignable
+entryRuleAssignable returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignableRule()); }
+ iv_ruleAssignable=ruleAssignable
+ { $current=$iv_ruleAssignable.current; }
+ EOF
+;
+
+// Rule Assignable
+ruleAssignable returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getAssignableAccess().getVariableParserRuleCall_0());
+ }
+ this_Variable_0=ruleVariable
+ {
+ $current = $this_Variable_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |(( RULE_LCURLY)=>
+ {
+ newCompositeNode(grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1());
+ }
+ this_Dictionary_1=ruleDictionary
+ {
+ $current = $this_Dictionary_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(( RULE_LBRACKET)=>
+ {
+ newCompositeNode(grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2());
+ }
+ this_AssignableArray_2=ruleAssignableArray
+ {
+ $current = $this_AssignableArray_2.current;
+ afterParserOrEnumRuleCall();
+ }
+))
+;
+
+
+
+
+
+// Entry rule entryRuleArg
+entryRuleArg returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getArgRule()); }
+ iv_ruleArg=ruleArg
+ { $current=$iv_ruleArg.current; }
+ EOF
+;
+
+// Rule Arg
+ruleArg returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0());
+ }
+ lv_exp_0_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgRule());
+ }
+ set(
+ $current,
+ "exp",
+ lv_exp_0_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ lv_splat_1_0=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_splat_1_0, grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getArgRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "splat",
+ true,
+ "ELLIPSIS");
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleArgLine
+entryRuleArgLine returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getArgLineRule()); }
+ iv_ruleArgLine=ruleArgLine
+ { $current=$iv_ruleArgLine.current; }
+ EOF
+;
+
+// Rule ArgLine
+ruleArgLine returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0());
+ }
+ lv_head_0_0=ruleArg {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgLineRule());
+ }
+ set(
+ $current,
+ "head",
+ lv_head_0_0,
+ "Arg");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_1=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_1, grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0());
+ }
+ lv_tail_2_0=ruleArg {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgLineRule());
+ }
+ add(
+ $current,
+ "tail",
+ lv_tail_2_0,
+ "Arg");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(this_COMMA_3=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_3, grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleExplicitArgList
+entryRuleExplicitArgList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExplicitArgListRule()); }
+ iv_ruleExplicitArgList=ruleExplicitArgList
+ { $current=$iv_ruleExplicitArgList.current; }
+ EOF
+;
+
+// Rule ExplicitArgList
+ruleExplicitArgList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0());
+ }
+ lv_lines_0_0=ruleArgLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_0_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((this_TERMINATOR_1=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0());
+ }
+ lv_lines_2_0=ruleArgLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_2_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(this_INDENT_3=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_3, grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0());
+ }
+ lv_lines_4_0=ruleArgLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_4_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_5=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_5, grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleArgList
+entryRuleArgList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getArgListRule()); }
+ iv_ruleArgList=ruleArgList
+ { $current=$iv_ruleArgList.current; }
+ EOF
+;
+
+// Rule ArgList
+ruleArgList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getArgListAccess().getArgListAction_0(),
+ $current);
+ }
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0());
+ }
+ lv_dummy_1_0=ruleExplicitArgList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgListRule());
+ }
+ set(
+ $current,
+ "dummy",
+ lv_dummy_1_0,
+ "ExplicitArgList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(this_INDENT_2=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_2, grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0());
+ }
+ lv_dummy_3_0=ruleExplicitArgList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgListRule());
+ }
+ set(
+ $current,
+ "dummy",
+ lv_dummy_3_0,
+ "ExplicitArgList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_4=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_4, grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleArray
+entryRuleArray returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getArrayRule()); }
+ iv_ruleArray=ruleArray
+ { $current=$iv_ruleArray.current; }
+ EOF
+;
+
+// Rule Array
+ruleArray returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((( RULE_LBRACKET)=>this_LBRACKET_0=RULE_LBRACKET
+ {
+ newLeafNode(this_LBRACKET_0, grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getArrayAccess().getArgListParserRuleCall_1());
+ }
+ this_ArgList_1=ruleArgList
+ {
+ $current = $this_ArgList_1.current;
+ afterParserOrEnumRuleCall();
+ }
+this_RBRACKET_2=RULE_RBRACKET
+ {
+ newLeafNode(this_RBRACKET_2, grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleDictionary
+entryRuleDictionary returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictionaryRule()); }
+ iv_ruleDictionary=ruleDictionary
+ { $current=$iv_ruleDictionary.current; }
+ EOF
+;
+
+// Rule Dictionary
+ruleDictionary returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((( RULE_LCURLY)=>this_LCURLY_0=RULE_LCURLY
+ {
+ newLeafNode(this_LCURLY_0, grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1());
+ }
+ this_DictItems_1=ruleDictItems
+ {
+ $current = $this_DictItems_1.current;
+ afterParserOrEnumRuleCall();
+ }
+this_RCURLY_2=RULE_RCURLY
+ {
+ newLeafNode(this_RCURLY_2, grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleDictItems
+entryRuleDictItems returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictItemsRule()); }
+ iv_ruleDictItems=ruleDictItems
+ { $current=$iv_ruleDictItems.current; }
+ EOF
+;
+
+// Rule DictItems
+ruleDictItems returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getDictItemsAccess().getDictItemsAction_0(),
+ $current);
+ }
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0());
+ }
+ lv_dummy_1_0=ruleExplicitDictItems {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemsRule());
+ }
+ set(
+ $current,
+ "dummy",
+ lv_dummy_1_0,
+ "ExplicitDictItems");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(this_INDENT_2=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_2, grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0());
+ }
+ lv_dummy_3_0=ruleExplicitDictItems {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemsRule());
+ }
+ set(
+ $current,
+ "dummy",
+ lv_dummy_3_0,
+ "ExplicitDictItems");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_4=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_4, grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleExplicitDictItems
+entryRuleExplicitDictItems returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExplicitDictItemsRule()); }
+ iv_ruleExplicitDictItems=ruleExplicitDictItems
+ { $current=$iv_ruleExplicitDictItems.current; }
+ EOF
+;
+
+// Rule ExplicitDictItems
+ruleExplicitDictItems returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0());
+ }
+ lv_lines_0_0=ruleDictLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_0_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((this_TERMINATOR_1=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0());
+ }
+ lv_lines_2_0=ruleDictLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_2_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(this_INDENT_3=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_3, grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0());
+ }
+ lv_lines_4_0=ruleDictLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_4_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_5=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_5, grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleDictLine
+entryRuleDictLine returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictLineRule()); }
+ iv_ruleDictLine=ruleDictLine
+ { $current=$iv_ruleDictLine.current; }
+ EOF
+;
+
+// Rule DictLine
+ruleDictLine returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0());
+ }
+ lv_head_0_0=ruleDictItem {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictLineRule());
+ }
+ set(
+ $current,
+ "head",
+ lv_head_0_0,
+ "DictItem");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_1=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_1, grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0());
+ }
+ lv_tail_2_0=ruleDictItem {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictLineRule());
+ }
+ add(
+ $current,
+ "tail",
+ lv_tail_2_0,
+ "DictItem");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(this_COMMA_3=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_3, grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleDictItem
+entryRuleDictItem returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictItemRule()); }
+ iv_ruleDictItem=ruleDictItem
+ { $current=$iv_ruleDictItem.current; }
+ EOF
+;
+
+// Rule DictItem
+ruleDictItem returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getDictItemAccess().getDictItemAction_0(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0());
+ }
+ lv_key_1_0=ruleDictKey {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ $current,
+ "key",
+ lv_key_1_0,
+ "DictKey");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COLON_2=RULE_COLON
+ {
+ newLeafNode(this_COLON_2, grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0());
+ }
+ lv_value_3_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(this_INDENT_4=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_4, grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0());
+ }
+ lv_value_5_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_5_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_6=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_6, grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2());
+ }
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleDictKey
+entryRuleDictKey returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictKeyRule()); }
+ iv_ruleDictKey=ruleDictKey
+ { $current=$iv_ruleDictKey.current; }
+ EOF
+;
+
+// Rule DictKey
+ruleDictKey returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0());
+ }
+ this_Literal_0=ruleLiteral
+ {
+ $current = $this_Literal_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getDictKeyAccess().getIdParserRuleCall_1());
+ }
+ this_Id_1=ruleId
+ {
+ $current = $this_Id_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleLambda
+entryRuleLambda returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLambdaRule()); }
+ iv_ruleLambda=ruleLambda
+ { $current=$iv_ruleLambda.current; }
+ EOF
+;
+
+// Rule Lambda
+ruleLambda returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((this_PARAM_START_0=RULE_PARAM_START
+ {
+ newLeafNode(this_PARAM_START_0, grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0());
+ }
+ lv_params_1_0=ruleParam {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ add(
+ $current,
+ "params",
+ lv_params_1_0,
+ "Param");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_2=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_2, grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0());
+ }
+ lv_params_3_0=ruleParam {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ add(
+ $current,
+ "params",
+ lv_params_3_0,
+ "Param");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)?this_PARAM_END_4=RULE_PARAM_END
+ {
+ newLeafNode(this_PARAM_END_4, grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2());
+ }
+)?(this_FUNC_ARROW_5=RULE_FUNC_ARROW
+ {
+ newLeafNode(this_FUNC_ARROW_5, grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0());
+ }
+
+ |this_BOUND_FUNC_ARROW_6=RULE_BOUND_FUNC_ARROW
+ {
+ newLeafNode(this_BOUND_FUNC_ARROW_6, grammarAccess.getLambdaAccess().getBOUND_FUNC_ARROWTerminalRuleCall_1_1());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0());
+ }
+ lv_body_7_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_7_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleParam
+entryRuleParam returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getParamRule()); }
+ iv_ruleParam=ruleParam
+ { $current=$iv_ruleParam.current; }
+ EOF
+;
+
+// Rule Param
+ruleParam returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getIdParserRuleCall_0_0());
+ }
+ this_Id_0=ruleId
+ {
+ $current = $this_Id_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |(( RULE_LBRACKET)=>
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getArrayParserRuleCall_0_1());
+ }
+ this_Array_1=ruleArray
+ {
+ $current = $this_Array_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(( RULE_LCURLY)=>
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2());
+ }
+ this_Dictionary_2=ruleDictionary
+ {
+ $current = $this_Dictionary_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3());
+ }
+ this_ThisProperty_3=ruleThisProperty
+ {
+ $current = $this_ThisProperty_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)((
+(
+ lv_splat_4_0=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_splat_4_0, grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getParamRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "splat",
+ true,
+ "ELLIPSIS");
+ }
+
+)
+)
+ |(this_EQUAL_5=RULE_EQUAL
+ {
+ newLeafNode(this_EQUAL_5, grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0());
+ }
+ lv_defaultValue_6_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getParamRule());
+ }
+ set(
+ $current,
+ "defaultValue",
+ lv_defaultValue_6_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleNumberLiteral
+entryRuleNumberLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNumberLiteralRule()); }
+ iv_ruleNumberLiteral=ruleNumberLiteral
+ { $current=$iv_ruleNumberLiteral.current; }
+ EOF
+;
+
+// Rule NumberLiteral
+ruleNumberLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0(),
+ $current);
+ }
+)this_NUMBER_1=RULE_NUMBER
+ {
+ newLeafNode(this_NUMBER_1, grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleStringLiteral
+entryRuleStringLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStringLiteralRule()); }
+ iv_ruleStringLiteral=ruleStringLiteral
+ { $current=$iv_ruleStringLiteral.current; }
+ EOF
+;
+
+// Rule StringLiteral
+ruleStringLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getStringLiteralAccess().getStringLiteralAction_0(),
+ $current);
+ }
+)this_STRING_1=RULE_STRING
+ {
+ newLeafNode(this_STRING_1, grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleBoolLiteral
+entryRuleBoolLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBoolLiteralRule()); }
+ iv_ruleBoolLiteral=ruleBoolLiteral
+ { $current=$iv_ruleBoolLiteral.current; }
+ EOF
+;
+
+// Rule BoolLiteral
+ruleBoolLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0(),
+ $current);
+ }
+)this_BOOL_1=RULE_BOOL
+ {
+ newLeafNode(this_BOOL_1, grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleJSLiteral
+entryRuleJSLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getJSLiteralRule()); }
+ iv_ruleJSLiteral=ruleJSLiteral
+ { $current=$iv_ruleJSLiteral.current; }
+ EOF
+;
+
+// Rule JSLiteral
+ruleJSLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getJSLiteralAccess().getJSLiteralAction_0(),
+ $current);
+ }
+)this_JS_1=RULE_JS
+ {
+ newLeafNode(this_JS_1, grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleRegexLiteral
+entryRuleRegexLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRegexLiteralRule()); }
+ iv_ruleRegexLiteral=ruleRegexLiteral
+ { $current=$iv_ruleRegexLiteral.current; }
+ EOF
+;
+
+// Rule RegexLiteral
+ruleRegexLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0(),
+ $current);
+ }
+)this_REGEX_1=RULE_REGEX
+ {
+ newLeafNode(this_REGEX_1, grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleLiteral
+entryRuleLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLiteralRule()); }
+ iv_ruleLiteral=ruleLiteral
+ { $current=$iv_ruleLiteral.current; }
+ EOF
+;
+
+// Rule Literal
+ruleLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0());
+ }
+ this_NumberLiteral_0=ruleNumberLiteral
+ {
+ $current = $this_NumberLiteral_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1());
+ }
+ this_StringLiteral_1=ruleStringLiteral
+ {
+ $current = $this_StringLiteral_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2());
+ }
+ this_BoolLiteral_2=ruleBoolLiteral
+ {
+ $current = $this_BoolLiteral_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3());
+ }
+ this_JSLiteral_3=ruleJSLiteral
+ {
+ $current = $this_JSLiteral_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4());
+ }
+ this_RegexLiteral_4=ruleRegexLiteral
+ {
+ $current = $this_RegexLiteral_4.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleParenthetical
+entryRuleParenthetical returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getParentheticalRule()); }
+ iv_ruleParenthetical=ruleParenthetical
+ { $current=$iv_ruleParenthetical.current; }
+ EOF
+;
+
+// Rule Parenthetical
+ruleParenthetical returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((( RULE_LPAREN RULE_INDENT))=>(this_LPAREN_0=RULE_LPAREN
+ {
+ newLeafNode(this_LPAREN_0, grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0());
+ }
+this_INDENT_1=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_1, grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1());
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0());
+ }
+ lv_content_2_0=ruleBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getParentheticalRule());
+ }
+ set(
+ $current,
+ "content",
+ lv_content_2_0,
+ "Body");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_3=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_3, grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2());
+ }
+this_RPAREN_4=RULE_RPAREN
+ {
+ newLeafNode(this_RPAREN_4, grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3());
+ }
+)
+ |((( RULE_LPAREN)=>this_LPAREN_5=RULE_LPAREN
+ {
+ newLeafNode(this_LPAREN_5, grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0());
+ }
+ lv_content_6_0=ruleBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getParentheticalRule());
+ }
+ set(
+ $current,
+ "content",
+ lv_content_6_0,
+ "Body");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_RPAREN_7=RULE_RPAREN
+ {
+ newLeafNode(this_RPAREN_7, grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2());
+ }
+))
+;
+
+
+
+
+
+RULE_ELLIPSIS : '...';
+
+RULE_DOT_DOT : '..';
+
+RULE_DOUBLE_COLON : '::';
+
+RULE_SHIFT : ('<<'|'>>');
+
+RULE_BOUND_FUNC_ARROW : '=>';
+
+RULE_FUNC_ARROW : '->';
+
+RULE_COMPARE : ('<'|'=='|'>'|'<='|'>='|'!=');
+
+RULE_COMPOUND_ASSIGN : ('+='|'-=');
+
+RULE_PLUS_PLUS : '++';
+
+RULE_MINUS_MINUS : '--';
+
+RULE_PARAM_END : '**)';
+
+RULE_PARAM_START : '(**';
+
+RULE_AT_SIGIL : '@';
+
+RULE_BOOL : ('true'|'false'|'undefined'|'null'|'on'|'no'|'yes'|'off');
+
+RULE_BY : 'by';
+
+RULE_CALL_END : '*)';
+
+RULE_CALL_START : '(*';
+
+RULE_CATCH : 'catch';
+
+RULE_CLASS : 'class';
+
+RULE_COLON : ':';
+
+RULE_COLON_SLASH : 'dummy COLON_SLASH';
+
+RULE_COMMA : ',';
+
+RULE_DOT : '.';
+
+RULE_ELSE : 'else';
+
+RULE_EQUAL : '=';
+
+RULE_EXTENDS : 'extends';
+
+RULE_FINALLY : 'finally';
+
+RULE_FOR : 'for';
+
+RULE_FORIN : 'in';
+
+RULE_FOROF : 'of';
+
+RULE_FUNC_EXIST : 'dummy FUNC_EXIST';
+
+RULE_HERECOMMENT : 'dummy HERECOMMENT';
+
+RULE_IF : ('if'|'unless');
+
+RULE_INDENT : '{*';
+
+RULE_INDEX_END : '*]';
+
+RULE_INDEX_PROTO : 'dummy INDEX_PROTO';
+
+RULE_INDEX_SOAK : 'dummy INDEX_SOAK';
+
+RULE_INDEX_START : '[*';
+
+RULE_JS : 'dummy JS';
+
+RULE_LBRACKET : '[';
+
+RULE_LCURLY : 'dummy LCURLY';
+
+RULE_LEADING_WHEN : 'dummy LEADING_WHEN';
+
+RULE_LOGIC : ('&&'|'||');
+
+RULE_LOOP : 'loop';
+
+RULE_LPAREN : '(';
+
+RULE_MATH : ('*'|'/');
+
+RULE_MINUS : '-';
+
+RULE_NEW : 'new';
+
+RULE_NUMBER : ('0'..'9')+;
+
+RULE_OUTDENT : '*}';
+
+RULE_OWN : 'own';
+
+RULE_PLUS : '+';
+
+RULE_POST_IF : 'dummy POST_IF';
+
+RULE_QUESTION : '?';
+
+RULE_QUESTION_DOT : '?.';
+
+RULE_RBRACKET : ']';
+
+RULE_RCURLY : 'dummy RCURLY';
+
+RULE_REGEX : '///' ( options {greedy=false;} : . )*'///';
+
+RULE_RELATION : ('in'|'of'|'instanceof');
+
+RULE_RETURN : 'return';
+
+RULE_RPAREN : ')';
+
+RULE_STATEMENT : ('break'|'continue'|'debugger');
+
+RULE_STRING : ('\'\'\'' ( options {greedy=false;} : . )*'\'\'\''|'\'' (~('\'') ('\\' ('b'|'t'|'n'|'f'|'r'|'u'|'"'|'\''|'\\')|~(('\\'|'\'')))*)? '\''|'"""' ( options {greedy=false;} : . )*'"""'|'"' (~('"') ('\\' ('b'|'t'|'n'|'f'|'r'|'u'|'"'|'\''|'\\')|~(('\\'|'"')))*)? '"');
+
+RULE_SUPER : 'super';
+
+RULE_SWITCH : 'switch';
+
+RULE_TERMINATOR : '\n'+;
+
+RULE_THEN : 'then';
+
+RULE_THIS : 'this';
+
+RULE_THROW : 'throw';
+
+RULE_TRY : 'try';
+
+RULE_UNARY : ('!'|'~');
+
+RULE_UNTIL : 'until';
+
+RULE_WHEN : 'when';
+
+RULE_WHILE : 'while';
+
+RULE_LOGIC_WORD : ('and'|'or');
+
+RULE_COMPARE_WORD : ('isnt'|'is');
+
+RULE_UNARY_WORD : ('new'|'do'|'not');
+
+RULE_ML_COMMENT : '###' ~('#') ( options {greedy=false;} : . )*'###';
+
+RULE_SL_COMMENT : '#' ~(('\n'|'\r'))* ('\r'? '\n')?;
+
+RULE_WS : (' '|'\t')+;
+
+RULE_IDENTIFIER : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
+
+
diff --git a/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.tokens b/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.tokens
new file mode 100644
index 0000000..6317da8
--- /dev/null
+++ b/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.tokens
@@ -0,0 +1,83 @@
+RULE_BOUND_FUNC_ARROW=67
+RULE_SWITCH=56
+RULE_THROW=13
+RULE_PARAM_START=64
+RULE_TERMINATOR=4
+RULE_CALL_END=10
+RULE_RETURN=11
+RULE_FOR=16
+RULE_BOOL=69
+RULE_LBRACKET=25
+RULE_DOUBLE_COLON=48
+RULE_MINUS_MINUS=41
+RULE_COMPARE_WORD=80
+RULE_OUTDENT=31
+RULE_RELATION=34
+RULE_REGEX=71
+RULE_CLASS=14
+RULE_WHILE=17
+RULE_COLON_SLASH=74
+RULE_FUNC_EXIST=44
+RULE_DOT=46
+RULE_POST_IF=12
+RULE_PLUS_PLUS=40
+RULE_OWN=20
+RULE_NUMBER=68
+RULE_LOOP=52
+RULE_LPAREN=72
+RULE_FUNC_ARROW=66
+RULE_AT_SIGIL=45
+RULE_EXTENDS=15
+RULE_SHIFT=35
+RULE_INDEX_END=50
+RULE_COMPARE=33
+RULE_QUESTION_DOT=47
+RULE_RBRACKET=28
+RULE_COMPOUND_ASSIGN=29
+RULE_SUPER=43
+RULE_THEN=78
+RULE_UNARY_WORD=81
+RULE_LEADING_WHEN=58
+RULE_DOT_DOT=26
+RULE_STATEMENT=5
+RULE_PLUS=36
+RULE_BY=24
+RULE_INDEX_SOAK=76
+RULE_CATCH=54
+RULE_CALL_START=8
+RULE_INDEX_PROTO=75
+RULE_IDENTIFIER=60
+RULE_COMMA=21
+RULE_TRY=53
+RULE_JS=70
+RULE_EQUAL=7
+RULE_INDENT=30
+RULE_HERECOMMENT=6
+RULE_FORIN=23
+RULE_ELLIPSIS=27
+T__85=85
+RULE_SL_COMMENT=83
+RULE_PARAM_END=65
+RULE_ML_COMMENT=82
+RULE_WHEN=18
+RULE_INDEX_START=49
+RULE_COLON=63
+RULE_MINUS=37
+RULE_STRING=9
+RULE_NEW=77
+RULE_LOGIC_WORD=79
+RULE_LOGIC=32
+RULE_RPAREN=73
+RULE_WS=84
+RULE_FOROF=22
+RULE_IF=59
+RULE_THIS=51
+RULE_UNARY=39
+RULE_RCURLY=62
+RULE_ELSE=57
+RULE_FINALLY=55
+RULE_MATH=38
+RULE_LCURLY=61
+RULE_UNTIL=19
+RULE_QUESTION=42
+'require'=85
diff --git a/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScriptLexer.java b/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScriptLexer.java
new file mode 100644
index 0000000..0a5e3b9
--- /dev/null
+++ b/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScriptLexer.java
@@ -0,0 +1,4227 @@
+package csep.parser.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.parser.antlr.Lexer;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalCoffeeScriptLexer extends Lexer {
+ public static final int RULE_BOUND_FUNC_ARROW=67;
+ public static final int RULE_SWITCH=56;
+ public static final int RULE_THROW=13;
+ public static final int RULE_PARAM_START=64;
+ public static final int RULE_TERMINATOR=4;
+ public static final int RULE_CALL_END=10;
+ public static final int RULE_RETURN=11;
+ public static final int RULE_FOR=16;
+ public static final int RULE_BOOL=69;
+ public static final int RULE_LBRACKET=25;
+ public static final int RULE_DOUBLE_COLON=48;
+ public static final int RULE_MINUS_MINUS=41;
+ public static final int RULE_COMPARE_WORD=80;
+ public static final int RULE_OUTDENT=31;
+ public static final int EOF=-1;
+ public static final int RULE_RELATION=34;
+ public static final int RULE_REGEX=71;
+ public static final int RULE_CLASS=14;
+ public static final int RULE_WHILE=17;
+ public static final int RULE_COLON_SLASH=74;
+ public static final int RULE_FUNC_EXIST=44;
+ public static final int RULE_DOT=46;
+ public static final int RULE_POST_IF=12;
+ public static final int RULE_PLUS_PLUS=40;
+ public static final int RULE_OWN=20;
+ public static final int RULE_NUMBER=68;
+ public static final int RULE_LOOP=52;
+ public static final int RULE_LPAREN=72;
+ public static final int RULE_FUNC_ARROW=66;
+ public static final int RULE_AT_SIGIL=45;
+ public static final int RULE_EXTENDS=15;
+ public static final int RULE_SHIFT=35;
+ public static final int RULE_INDEX_END=50;
+ public static final int RULE_COMPARE=33;
+ public static final int RULE_QUESTION_DOT=47;
+ public static final int RULE_RBRACKET=28;
+ public static final int RULE_COMPOUND_ASSIGN=29;
+ public static final int RULE_SUPER=43;
+ public static final int RULE_THEN=78;
+ public static final int RULE_UNARY_WORD=81;
+ public static final int RULE_LEADING_WHEN=58;
+ public static final int RULE_DOT_DOT=26;
+ public static final int RULE_STATEMENT=5;
+ public static final int RULE_PLUS=36;
+ public static final int RULE_BY=24;
+ public static final int RULE_CATCH=54;
+ public static final int RULE_INDEX_SOAK=76;
+ public static final int RULE_CALL_START=8;
+ public static final int RULE_COMMA=21;
+ public static final int RULE_IDENTIFIER=60;
+ public static final int RULE_INDEX_PROTO=75;
+ public static final int RULE_TRY=53;
+ public static final int RULE_INDENT=30;
+ public static final int RULE_EQUAL=7;
+ public static final int RULE_JS=70;
+ public static final int RULE_HERECOMMENT=6;
+ public static final int RULE_ELLIPSIS=27;
+ public static final int RULE_FORIN=23;
+ public static final int T__85=85;
+ public static final int RULE_SL_COMMENT=83;
+ public static final int RULE_PARAM_END=65;
+ public static final int RULE_WHEN=18;
+ public static final int RULE_ML_COMMENT=82;
+ public static final int RULE_INDEX_START=49;
+ public static final int RULE_MINUS=37;
+ public static final int RULE_COLON=63;
+ public static final int RULE_STRING=9;
+ public static final int RULE_NEW=77;
+ public static final int RULE_LOGIC_WORD=79;
+ public static final int RULE_LOGIC=32;
+ public static final int RULE_RPAREN=73;
+ public static final int RULE_WS=84;
+ public static final int RULE_FOROF=22;
+ public static final int RULE_UNARY=39;
+ public static final int RULE_THIS=51;
+ public static final int RULE_IF=59;
+ public static final int RULE_ELSE=57;
+ public static final int RULE_RCURLY=62;
+ public static final int RULE_MATH=38;
+ public static final int RULE_FINALLY=55;
+ public static final int RULE_QUESTION=42;
+ public static final int RULE_UNTIL=19;
+ public static final int RULE_LCURLY=61;
+
+ // delegates
+ // delegators
+
+ public InternalCoffeeScriptLexer() {;}
+ public InternalCoffeeScriptLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalCoffeeScriptLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g"; }
+
+ // $ANTLR start "T__85"
+ public final void mT__85() throws RecognitionException {
+ try {
+ int _type = T__85;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:11:7: ( 'require' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:11:9: 'require'
+ {
+ match("require");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__85"
+
+ // $ANTLR start "RULE_ELLIPSIS"
+ public final void mRULE_ELLIPSIS() throws RecognitionException {
+ try {
+ int _type = RULE_ELLIPSIS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5395:15: ( '...' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5395:17: '...'
+ {
+ match("...");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ELLIPSIS"
+
+ // $ANTLR start "RULE_DOT_DOT"
+ public final void mRULE_DOT_DOT() throws RecognitionException {
+ try {
+ int _type = RULE_DOT_DOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5397:14: ( '..' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5397:16: '..'
+ {
+ match("..");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DOT_DOT"
+
+ // $ANTLR start "RULE_DOUBLE_COLON"
+ public final void mRULE_DOUBLE_COLON() throws RecognitionException {
+ try {
+ int _type = RULE_DOUBLE_COLON;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5399:19: ( '::' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5399:21: '::'
+ {
+ match("::");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DOUBLE_COLON"
+
+ // $ANTLR start "RULE_SHIFT"
+ public final void mRULE_SHIFT() throws RecognitionException {
+ try {
+ int _type = RULE_SHIFT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5401:12: ( ( '<<' | '>>' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5401:14: ( '<<' | '>>' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5401:14: ( '<<' | '>>' )
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0=='<') ) {
+ alt1=1;
+ }
+ else if ( (LA1_0=='>') ) {
+ alt1=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 1, 0, input);
+
+ throw nvae;
+ }
+ switch (alt1) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5401:15: '<<'
+ {
+ match("<<");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5401:20: '>>'
+ {
+ match(">>");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SHIFT"
+
+ // $ANTLR start "RULE_BOUND_FUNC_ARROW"
+ public final void mRULE_BOUND_FUNC_ARROW() throws RecognitionException {
+ try {
+ int _type = RULE_BOUND_FUNC_ARROW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5403:23: ( '=>' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5403:25: '=>'
+ {
+ match("=>");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_BOUND_FUNC_ARROW"
+
+ // $ANTLR start "RULE_FUNC_ARROW"
+ public final void mRULE_FUNC_ARROW() throws RecognitionException {
+ try {
+ int _type = RULE_FUNC_ARROW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5405:17: ( '->' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5405:19: '->'
+ {
+ match("->");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FUNC_ARROW"
+
+ // $ANTLR start "RULE_COMPARE"
+ public final void mRULE_COMPARE() throws RecognitionException {
+ try {
+ int _type = RULE_COMPARE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5407:14: ( ( '<' | '==' | '>' | '<=' | '>=' | '!=' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5407:16: ( '<' | '==' | '>' | '<=' | '>=' | '!=' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5407:16: ( '<' | '==' | '>' | '<=' | '>=' | '!=' )
+ int alt2=6;
+ switch ( input.LA(1) ) {
+ case '<':
+ {
+ int LA2_1 = input.LA(2);
+
+ if ( (LA2_1=='=') ) {
+ alt2=4;
+ }
+ else {
+ alt2=1;}
+ }
+ break;
+ case '=':
+ {
+ alt2=2;
+ }
+ break;
+ case '>':
+ {
+ int LA2_3 = input.LA(2);
+
+ if ( (LA2_3=='=') ) {
+ alt2=5;
+ }
+ else {
+ alt2=3;}
+ }
+ break;
+ case '!':
+ {
+ alt2=6;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt2) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5407:17: '<'
+ {
+ match('<');
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5407:21: '=='
+ {
+ match("==");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5407:26: '>'
+ {
+ match('>');
+
+ }
+ break;
+ case 4 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5407:30: '<='
+ {
+ match("<=");
+
+
+ }
+ break;
+ case 5 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5407:35: '>='
+ {
+ match(">=");
+
+
+ }
+ break;
+ case 6 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5407:40: '!='
+ {
+ match("!=");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMPARE"
+
+ // $ANTLR start "RULE_COMPOUND_ASSIGN"
+ public final void mRULE_COMPOUND_ASSIGN() throws RecognitionException {
+ try {
+ int _type = RULE_COMPOUND_ASSIGN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5409:22: ( ( '+=' | '-=' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5409:24: ( '+=' | '-=' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5409:24: ( '+=' | '-=' )
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0=='+') ) {
+ alt3=1;
+ }
+ else if ( (LA3_0=='-') ) {
+ alt3=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 3, 0, input);
+
+ throw nvae;
+ }
+ switch (alt3) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5409:25: '+='
+ {
+ match("+=");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5409:30: '-='
+ {
+ match("-=");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMPOUND_ASSIGN"
+
+ // $ANTLR start "RULE_PLUS_PLUS"
+ public final void mRULE_PLUS_PLUS() throws RecognitionException {
+ try {
+ int _type = RULE_PLUS_PLUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5411:16: ( '++' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5411:18: '++'
+ {
+ match("++");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PLUS_PLUS"
+
+ // $ANTLR start "RULE_MINUS_MINUS"
+ public final void mRULE_MINUS_MINUS() throws RecognitionException {
+ try {
+ int _type = RULE_MINUS_MINUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5413:18: ( '--' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5413:20: '--'
+ {
+ match("--");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_MINUS_MINUS"
+
+ // $ANTLR start "RULE_PARAM_END"
+ public final void mRULE_PARAM_END() throws RecognitionException {
+ try {
+ int _type = RULE_PARAM_END;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5415:16: ( '**)' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5415:18: '**)'
+ {
+ match("**)");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PARAM_END"
+
+ // $ANTLR start "RULE_PARAM_START"
+ public final void mRULE_PARAM_START() throws RecognitionException {
+ try {
+ int _type = RULE_PARAM_START;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5417:18: ( '(**' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5417:20: '(**'
+ {
+ match("(**");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PARAM_START"
+
+ // $ANTLR start "RULE_AT_SIGIL"
+ public final void mRULE_AT_SIGIL() throws RecognitionException {
+ try {
+ int _type = RULE_AT_SIGIL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5419:15: ( '@' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5419:17: '@'
+ {
+ match('@');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_AT_SIGIL"
+
+ // $ANTLR start "RULE_BOOL"
+ public final void mRULE_BOOL() throws RecognitionException {
+ try {
+ int _type = RULE_BOOL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:11: ( ( 'true' | 'false' | 'undefined' | 'null' | 'on' | 'no' | 'yes' | 'off' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:13: ( 'true' | 'false' | 'undefined' | 'null' | 'on' | 'no' | 'yes' | 'off' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:13: ( 'true' | 'false' | 'undefined' | 'null' | 'on' | 'no' | 'yes' | 'off' )
+ int alt4=8;
+ alt4 = dfa4.predict(input);
+ switch (alt4) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:14: 'true'
+ {
+ match("true");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:21: 'false'
+ {
+ match("false");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:29: 'undefined'
+ {
+ match("undefined");
+
+
+ }
+ break;
+ case 4 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:41: 'null'
+ {
+ match("null");
+
+
+ }
+ break;
+ case 5 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:48: 'on'
+ {
+ match("on");
+
+
+ }
+ break;
+ case 6 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:53: 'no'
+ {
+ match("no");
+
+
+ }
+ break;
+ case 7 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:58: 'yes'
+ {
+ match("yes");
+
+
+ }
+ break;
+ case 8 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5421:64: 'off'
+ {
+ match("off");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_BOOL"
+
+ // $ANTLR start "RULE_BY"
+ public final void mRULE_BY() throws RecognitionException {
+ try {
+ int _type = RULE_BY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5423:9: ( 'by' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5423:11: 'by'
+ {
+ match("by");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_BY"
+
+ // $ANTLR start "RULE_CALL_END"
+ public final void mRULE_CALL_END() throws RecognitionException {
+ try {
+ int _type = RULE_CALL_END;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5425:15: ( '*)' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5425:17: '*)'
+ {
+ match("*)");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CALL_END"
+
+ // $ANTLR start "RULE_CALL_START"
+ public final void mRULE_CALL_START() throws RecognitionException {
+ try {
+ int _type = RULE_CALL_START;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5427:17: ( '(*' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5427:19: '(*'
+ {
+ match("(*");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CALL_START"
+
+ // $ANTLR start "RULE_CATCH"
+ public final void mRULE_CATCH() throws RecognitionException {
+ try {
+ int _type = RULE_CATCH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5429:12: ( 'catch' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5429:14: 'catch'
+ {
+ match("catch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CATCH"
+
+ // $ANTLR start "RULE_CLASS"
+ public final void mRULE_CLASS() throws RecognitionException {
+ try {
+ int _type = RULE_CLASS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5431:12: ( 'class' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5431:14: 'class'
+ {
+ match("class");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CLASS"
+
+ // $ANTLR start "RULE_COLON"
+ public final void mRULE_COLON() throws RecognitionException {
+ try {
+ int _type = RULE_COLON;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5433:12: ( ':' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5433:14: ':'
+ {
+ match(':');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COLON"
+
+ // $ANTLR start "RULE_COLON_SLASH"
+ public final void mRULE_COLON_SLASH() throws RecognitionException {
+ try {
+ int _type = RULE_COLON_SLASH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5435:18: ( 'dummy COLON_SLASH' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5435:20: 'dummy COLON_SLASH'
+ {
+ match("dummy COLON_SLASH");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COLON_SLASH"
+
+ // $ANTLR start "RULE_COMMA"
+ public final void mRULE_COMMA() throws RecognitionException {
+ try {
+ int _type = RULE_COMMA;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5437:12: ( ',' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5437:14: ','
+ {
+ match(',');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMMA"
+
+ // $ANTLR start "RULE_DOT"
+ public final void mRULE_DOT() throws RecognitionException {
+ try {
+ int _type = RULE_DOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5439:10: ( '.' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5439:12: '.'
+ {
+ match('.');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DOT"
+
+ // $ANTLR start "RULE_ELSE"
+ public final void mRULE_ELSE() throws RecognitionException {
+ try {
+ int _type = RULE_ELSE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5441:11: ( 'else' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5441:13: 'else'
+ {
+ match("else");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ELSE"
+
+ // $ANTLR start "RULE_EQUAL"
+ public final void mRULE_EQUAL() throws RecognitionException {
+ try {
+ int _type = RULE_EQUAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5443:12: ( '=' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5443:14: '='
+ {
+ match('=');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_EQUAL"
+
+ // $ANTLR start "RULE_EXTENDS"
+ public final void mRULE_EXTENDS() throws RecognitionException {
+ try {
+ int _type = RULE_EXTENDS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5445:14: ( 'extends' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5445:16: 'extends'
+ {
+ match("extends");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_EXTENDS"
+
+ // $ANTLR start "RULE_FINALLY"
+ public final void mRULE_FINALLY() throws RecognitionException {
+ try {
+ int _type = RULE_FINALLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5447:14: ( 'finally' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5447:16: 'finally'
+ {
+ match("finally");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FINALLY"
+
+ // $ANTLR start "RULE_FOR"
+ public final void mRULE_FOR() throws RecognitionException {
+ try {
+ int _type = RULE_FOR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5449:10: ( 'for' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5449:12: 'for'
+ {
+ match("for");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FOR"
+
+ // $ANTLR start "RULE_FORIN"
+ public final void mRULE_FORIN() throws RecognitionException {
+ try {
+ int _type = RULE_FORIN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5451:12: ( 'in' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5451:14: 'in'
+ {
+ match("in");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FORIN"
+
+ // $ANTLR start "RULE_FOROF"
+ public final void mRULE_FOROF() throws RecognitionException {
+ try {
+ int _type = RULE_FOROF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5453:12: ( 'of' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5453:14: 'of'
+ {
+ match("of");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FOROF"
+
+ // $ANTLR start "RULE_FUNC_EXIST"
+ public final void mRULE_FUNC_EXIST() throws RecognitionException {
+ try {
+ int _type = RULE_FUNC_EXIST;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5455:17: ( 'dummy FUNC_EXIST' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5455:19: 'dummy FUNC_EXIST'
+ {
+ match("dummy FUNC_EXIST");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FUNC_EXIST"
+
+ // $ANTLR start "RULE_HERECOMMENT"
+ public final void mRULE_HERECOMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_HERECOMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5457:18: ( 'dummy HERECOMMENT' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5457:20: 'dummy HERECOMMENT'
+ {
+ match("dummy HERECOMMENT");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_HERECOMMENT"
+
+ // $ANTLR start "RULE_IF"
+ public final void mRULE_IF() throws RecognitionException {
+ try {
+ int _type = RULE_IF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5459:9: ( ( 'if' | 'unless' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5459:11: ( 'if' | 'unless' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5459:11: ( 'if' | 'unless' )
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0=='i') ) {
+ alt5=1;
+ }
+ else if ( (LA5_0=='u') ) {
+ alt5=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 5, 0, input);
+
+ throw nvae;
+ }
+ switch (alt5) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5459:12: 'if'
+ {
+ match("if");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5459:17: 'unless'
+ {
+ match("unless");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_IF"
+
+ // $ANTLR start "RULE_INDENT"
+ public final void mRULE_INDENT() throws RecognitionException {
+ try {
+ int _type = RULE_INDENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5461:13: ( '{*' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5461:15: '{*'
+ {
+ match("{*");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDENT"
+
+ // $ANTLR start "RULE_INDEX_END"
+ public final void mRULE_INDEX_END() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_END;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5463:16: ( '*]' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5463:18: '*]'
+ {
+ match("*]");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_END"
+
+ // $ANTLR start "RULE_INDEX_PROTO"
+ public final void mRULE_INDEX_PROTO() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_PROTO;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5465:18: ( 'dummy INDEX_PROTO' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5465:20: 'dummy INDEX_PROTO'
+ {
+ match("dummy INDEX_PROTO");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_PROTO"
+
+ // $ANTLR start "RULE_INDEX_SOAK"
+ public final void mRULE_INDEX_SOAK() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_SOAK;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5467:17: ( 'dummy INDEX_SOAK' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5467:19: 'dummy INDEX_SOAK'
+ {
+ match("dummy INDEX_SOAK");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_SOAK"
+
+ // $ANTLR start "RULE_INDEX_START"
+ public final void mRULE_INDEX_START() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_START;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5469:18: ( '[*' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5469:20: '[*'
+ {
+ match("[*");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_START"
+
+ // $ANTLR start "RULE_JS"
+ public final void mRULE_JS() throws RecognitionException {
+ try {
+ int _type = RULE_JS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5471:9: ( 'dummy JS' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5471:11: 'dummy JS'
+ {
+ match("dummy JS");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_JS"
+
+ // $ANTLR start "RULE_LBRACKET"
+ public final void mRULE_LBRACKET() throws RecognitionException {
+ try {
+ int _type = RULE_LBRACKET;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5473:15: ( '[' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5473:17: '['
+ {
+ match('[');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LBRACKET"
+
+ // $ANTLR start "RULE_LCURLY"
+ public final void mRULE_LCURLY() throws RecognitionException {
+ try {
+ int _type = RULE_LCURLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5475:13: ( 'dummy LCURLY' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5475:15: 'dummy LCURLY'
+ {
+ match("dummy LCURLY");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LCURLY"
+
+ // $ANTLR start "RULE_LEADING_WHEN"
+ public final void mRULE_LEADING_WHEN() throws RecognitionException {
+ try {
+ int _type = RULE_LEADING_WHEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5477:19: ( 'dummy LEADING_WHEN' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5477:21: 'dummy LEADING_WHEN'
+ {
+ match("dummy LEADING_WHEN");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LEADING_WHEN"
+
+ // $ANTLR start "RULE_LOGIC"
+ public final void mRULE_LOGIC() throws RecognitionException {
+ try {
+ int _type = RULE_LOGIC;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5479:12: ( ( '&&' | '||' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5479:14: ( '&&' | '||' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5479:14: ( '&&' | '||' )
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0=='&') ) {
+ alt6=1;
+ }
+ else if ( (LA6_0=='|') ) {
+ alt6=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 6, 0, input);
+
+ throw nvae;
+ }
+ switch (alt6) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5479:15: '&&'
+ {
+ match("&&");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5479:20: '||'
+ {
+ match("||");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOGIC"
+
+ // $ANTLR start "RULE_LOOP"
+ public final void mRULE_LOOP() throws RecognitionException {
+ try {
+ int _type = RULE_LOOP;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5481:11: ( 'loop' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5481:13: 'loop'
+ {
+ match("loop");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOOP"
+
+ // $ANTLR start "RULE_LPAREN"
+ public final void mRULE_LPAREN() throws RecognitionException {
+ try {
+ int _type = RULE_LPAREN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5483:13: ( '(' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5483:15: '('
+ {
+ match('(');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LPAREN"
+
+ // $ANTLR start "RULE_MATH"
+ public final void mRULE_MATH() throws RecognitionException {
+ try {
+ int _type = RULE_MATH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5485:11: ( ( '*' | '/' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5485:13: ( '*' | '/' )
+ {
+ if ( input.LA(1)=='*'||input.LA(1)=='/' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_MATH"
+
+ // $ANTLR start "RULE_MINUS"
+ public final void mRULE_MINUS() throws RecognitionException {
+ try {
+ int _type = RULE_MINUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5487:12: ( '-' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5487:14: '-'
+ {
+ match('-');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_MINUS"
+
+ // $ANTLR start "RULE_NEW"
+ public final void mRULE_NEW() throws RecognitionException {
+ try {
+ int _type = RULE_NEW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5489:10: ( 'new' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5489:12: 'new'
+ {
+ match("new");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_NEW"
+
+ // $ANTLR start "RULE_NUMBER"
+ public final void mRULE_NUMBER() throws RecognitionException {
+ try {
+ int _type = RULE_NUMBER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5491:13: ( ( '0' .. '9' )+ )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5491:15: ( '0' .. '9' )+
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5491:15: ( '0' .. '9' )+
+ int cnt7=0;
+ loop7:
+ do {
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( ((LA7_0>='0' && LA7_0<='9')) ) {
+ alt7=1;
+ }
+
+
+ switch (alt7) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5491:16: '0' .. '9'
+ {
+ matchRange('0','9');
+
+ }
+ break;
+
+ default :
+ if ( cnt7 >= 1 ) break loop7;
+ EarlyExitException eee =
+ new EarlyExitException(7, input);
+ throw eee;
+ }
+ cnt7++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_NUMBER"
+
+ // $ANTLR start "RULE_OUTDENT"
+ public final void mRULE_OUTDENT() throws RecognitionException {
+ try {
+ int _type = RULE_OUTDENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5493:14: ( '*}' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5493:16: '*}'
+ {
+ match("*}");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_OUTDENT"
+
+ // $ANTLR start "RULE_OWN"
+ public final void mRULE_OWN() throws RecognitionException {
+ try {
+ int _type = RULE_OWN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5495:10: ( 'own' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5495:12: 'own'
+ {
+ match("own");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_OWN"
+
+ // $ANTLR start "RULE_PLUS"
+ public final void mRULE_PLUS() throws RecognitionException {
+ try {
+ int _type = RULE_PLUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5497:11: ( '+' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5497:13: '+'
+ {
+ match('+');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PLUS"
+
+ // $ANTLR start "RULE_POST_IF"
+ public final void mRULE_POST_IF() throws RecognitionException {
+ try {
+ int _type = RULE_POST_IF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5499:14: ( 'dummy POST_IF' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5499:16: 'dummy POST_IF'
+ {
+ match("dummy POST_IF");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_POST_IF"
+
+ // $ANTLR start "RULE_QUESTION"
+ public final void mRULE_QUESTION() throws RecognitionException {
+ try {
+ int _type = RULE_QUESTION;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5501:15: ( '?' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5501:17: '?'
+ {
+ match('?');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_QUESTION"
+
+ // $ANTLR start "RULE_QUESTION_DOT"
+ public final void mRULE_QUESTION_DOT() throws RecognitionException {
+ try {
+ int _type = RULE_QUESTION_DOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5503:19: ( '?.' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5503:21: '?.'
+ {
+ match("?.");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_QUESTION_DOT"
+
+ // $ANTLR start "RULE_RBRACKET"
+ public final void mRULE_RBRACKET() throws RecognitionException {
+ try {
+ int _type = RULE_RBRACKET;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5505:15: ( ']' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5505:17: ']'
+ {
+ match(']');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RBRACKET"
+
+ // $ANTLR start "RULE_RCURLY"
+ public final void mRULE_RCURLY() throws RecognitionException {
+ try {
+ int _type = RULE_RCURLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5507:13: ( 'dummy RCURLY' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5507:15: 'dummy RCURLY'
+ {
+ match("dummy RCURLY");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RCURLY"
+
+ // $ANTLR start "RULE_REGEX"
+ public final void mRULE_REGEX() throws RecognitionException {
+ try {
+ int _type = RULE_REGEX;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5509:12: ( '///' ( options {greedy=false; } : . )* '///' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5509:14: '///' ( options {greedy=false; } : . )* '///'
+ {
+ match("///");
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5509:20: ( options {greedy=false; } : . )*
+ loop8:
+ do {
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='/') ) {
+ int LA8_1 = input.LA(2);
+
+ if ( (LA8_1=='/') ) {
+ int LA8_3 = input.LA(3);
+
+ if ( (LA8_3=='/') ) {
+ alt8=2;
+ }
+ else if ( ((LA8_3>='\u0000' && LA8_3<='.')||(LA8_3>='0' && LA8_3<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ }
+ else if ( ((LA8_1>='\u0000' && LA8_1<='.')||(LA8_1>='0' && LA8_1<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ }
+ else if ( ((LA8_0>='\u0000' && LA8_0<='.')||(LA8_0>='0' && LA8_0<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ switch (alt8) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5509:48: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop8;
+ }
+ } while (true);
+
+ match("///");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_REGEX"
+
+ // $ANTLR start "RULE_RELATION"
+ public final void mRULE_RELATION() throws RecognitionException {
+ try {
+ int _type = RULE_RELATION;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5511:15: ( ( 'in' | 'of' | 'instanceof' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5511:17: ( 'in' | 'of' | 'instanceof' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5511:17: ( 'in' | 'of' | 'instanceof' )
+ int alt9=3;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0=='i') ) {
+ int LA9_1 = input.LA(2);
+
+ if ( (LA9_1=='n') ) {
+ int LA9_3 = input.LA(3);
+
+ if ( (LA9_3=='s') ) {
+ alt9=3;
+ }
+ else {
+ alt9=1;}
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA9_0=='o') ) {
+ alt9=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 0, input);
+
+ throw nvae;
+ }
+ switch (alt9) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5511:18: 'in'
+ {
+ match("in");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5511:23: 'of'
+ {
+ match("of");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5511:28: 'instanceof'
+ {
+ match("instanceof");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RELATION"
+
+ // $ANTLR start "RULE_RETURN"
+ public final void mRULE_RETURN() throws RecognitionException {
+ try {
+ int _type = RULE_RETURN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5513:13: ( 'return' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5513:15: 'return'
+ {
+ match("return");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RETURN"
+
+ // $ANTLR start "RULE_RPAREN"
+ public final void mRULE_RPAREN() throws RecognitionException {
+ try {
+ int _type = RULE_RPAREN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5515:13: ( ')' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5515:15: ')'
+ {
+ match(')');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RPAREN"
+
+ // $ANTLR start "RULE_STATEMENT"
+ public final void mRULE_STATEMENT() throws RecognitionException {
+ try {
+ int _type = RULE_STATEMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5517:16: ( ( 'break' | 'continue' | 'debugger' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5517:18: ( 'break' | 'continue' | 'debugger' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5517:18: ( 'break' | 'continue' | 'debugger' )
+ int alt10=3;
+ switch ( input.LA(1) ) {
+ case 'b':
+ {
+ alt10=1;
+ }
+ break;
+ case 'c':
+ {
+ alt10=2;
+ }
+ break;
+ case 'd':
+ {
+ alt10=3;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 10, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt10) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5517:19: 'break'
+ {
+ match("break");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5517:27: 'continue'
+ {
+ match("continue");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5517:38: 'debugger'
+ {
+ match("debugger");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STATEMENT"
+
+ // $ANTLR start "RULE_STRING"
+ public final void mRULE_STRING() throws RecognitionException {
+ try {
+ int _type = RULE_STRING;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:13: ( ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:15: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:15: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"' )
+ int alt17=4;
+ int LA17_0 = input.LA(1);
+
+ if ( (LA17_0=='\'') ) {
+ int LA17_1 = input.LA(2);
+
+ if ( (LA17_1=='\'') ) {
+ int LA17_3 = input.LA(3);
+
+ if ( (LA17_3=='\'') ) {
+ alt17=1;
+ }
+ else {
+ alt17=2;}
+ }
+ else if ( ((LA17_1>='\u0000' && LA17_1<='&')||(LA17_1>='(' && LA17_1<='\uFFFF')) ) {
+ alt17=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA17_0=='\"') ) {
+ int LA17_2 = input.LA(2);
+
+ if ( (LA17_2=='\"') ) {
+ int LA17_5 = input.LA(3);
+
+ if ( (LA17_5=='\"') ) {
+ alt17=3;
+ }
+ else {
+ alt17=4;}
+ }
+ else if ( ((LA17_2>='\u0000' && LA17_2<='!')||(LA17_2>='#' && LA17_2<='\uFFFF')) ) {
+ alt17=4;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 2, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 0, input);
+
+ throw nvae;
+ }
+ switch (alt17) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:16: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
+ {
+ match("'''");
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:25: ( options {greedy=false; } : . )*
+ loop11:
+ do {
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0=='\'') ) {
+ int LA11_1 = input.LA(2);
+
+ if ( (LA11_1=='\'') ) {
+ int LA11_3 = input.LA(3);
+
+ if ( (LA11_3=='\'') ) {
+ alt11=2;
+ }
+ else if ( ((LA11_3>='\u0000' && LA11_3<='&')||(LA11_3>='(' && LA11_3<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ }
+ else if ( ((LA11_1>='\u0000' && LA11_1<='&')||(LA11_1>='(' && LA11_1<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ }
+ else if ( ((LA11_0>='\u0000' && LA11_0<='&')||(LA11_0>='(' && LA11_0<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ switch (alt11) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:53: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop11;
+ }
+ } while (true);
+
+ match("'''");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:66: '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\''
+ {
+ match('\'');
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:71: (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )?
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( ((LA13_0>='\u0000' && LA13_0<='&')||(LA13_0>='(' && LA13_0<='\uFFFF')) ) {
+ alt13=1;
+ }
+ switch (alt13) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:72: ~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )*
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:80: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )*
+ loop12:
+ do {
+ int alt12=3;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0=='\\') ) {
+ alt12=1;
+ }
+ else if ( ((LA12_0>='\u0000' && LA12_0<='&')||(LA12_0>='(' && LA12_0<='[')||(LA12_0>=']' && LA12_0<='\uFFFF')) ) {
+ alt12=2;
+ }
+
+
+ switch (alt12) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:81: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' )
+ {
+ match('\\');
+ if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||(input.LA(1)>='t' && input.LA(1)<='u') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:126: ~ ( ( '\\\\' | '\\'' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop12;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ match('\'');
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:150: '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"'
+ {
+ match("\"\"\"");
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:156: ( options {greedy=false; } : . )*
+ loop14:
+ do {
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0=='\"') ) {
+ int LA14_1 = input.LA(2);
+
+ if ( (LA14_1=='\"') ) {
+ int LA14_3 = input.LA(3);
+
+ if ( (LA14_3=='\"') ) {
+ alt14=2;
+ }
+ else if ( ((LA14_3>='\u0000' && LA14_3<='!')||(LA14_3>='#' && LA14_3<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ }
+ else if ( ((LA14_1>='\u0000' && LA14_1<='!')||(LA14_1>='#' && LA14_1<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ }
+ else if ( ((LA14_0>='\u0000' && LA14_0<='!')||(LA14_0>='#' && LA14_0<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ switch (alt14) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:184: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop14;
+ }
+ } while (true);
+
+ match("\"\"\"");
+
+
+ }
+ break;
+ case 4 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:194: '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"'
+ {
+ match('\"');
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:198: (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )?
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( ((LA16_0>='\u0000' && LA16_0<='!')||(LA16_0>='#' && LA16_0<='\uFFFF')) ) {
+ alt16=1;
+ }
+ switch (alt16) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:199: ~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )*
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:206: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )*
+ loop15:
+ do {
+ int alt15=3;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0=='\\') ) {
+ alt15=1;
+ }
+ else if ( ((LA15_0>='\u0000' && LA15_0<='!')||(LA15_0>='#' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) {
+ alt15=2;
+ }
+
+
+ switch (alt15) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:207: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' )
+ {
+ match('\\');
+ if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||(input.LA(1)>='t' && input.LA(1)<='u') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5519:252: ~ ( ( '\\\\' | '\"' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop15;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ match('\"');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STRING"
+
+ // $ANTLR start "RULE_SUPER"
+ public final void mRULE_SUPER() throws RecognitionException {
+ try {
+ int _type = RULE_SUPER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5521:12: ( 'super' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5521:14: 'super'
+ {
+ match("super");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SUPER"
+
+ // $ANTLR start "RULE_SWITCH"
+ public final void mRULE_SWITCH() throws RecognitionException {
+ try {
+ int _type = RULE_SWITCH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5523:13: ( 'switch' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5523:15: 'switch'
+ {
+ match("switch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SWITCH"
+
+ // $ANTLR start "RULE_TERMINATOR"
+ public final void mRULE_TERMINATOR() throws RecognitionException {
+ try {
+ int _type = RULE_TERMINATOR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5525:17: ( ( '\\n' )+ )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5525:19: ( '\\n' )+
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5525:19: ( '\\n' )+
+ int cnt18=0;
+ loop18:
+ do {
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0=='\n') ) {
+ alt18=1;
+ }
+
+
+ switch (alt18) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5525:19: '\\n'
+ {
+ match('\n');
+
+ }
+ break;
+
+ default :
+ if ( cnt18 >= 1 ) break loop18;
+ EarlyExitException eee =
+ new EarlyExitException(18, input);
+ throw eee;
+ }
+ cnt18++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_TERMINATOR"
+
+ // $ANTLR start "RULE_THEN"
+ public final void mRULE_THEN() throws RecognitionException {
+ try {
+ int _type = RULE_THEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5527:11: ( 'then' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5527:13: 'then'
+ {
+ match("then");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_THEN"
+
+ // $ANTLR start "RULE_THIS"
+ public final void mRULE_THIS() throws RecognitionException {
+ try {
+ int _type = RULE_THIS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5529:11: ( 'this' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5529:13: 'this'
+ {
+ match("this");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_THIS"
+
+ // $ANTLR start "RULE_THROW"
+ public final void mRULE_THROW() throws RecognitionException {
+ try {
+ int _type = RULE_THROW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5531:12: ( 'throw' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5531:14: 'throw'
+ {
+ match("throw");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_THROW"
+
+ // $ANTLR start "RULE_TRY"
+ public final void mRULE_TRY() throws RecognitionException {
+ try {
+ int _type = RULE_TRY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5533:10: ( 'try' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5533:12: 'try'
+ {
+ match("try");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_TRY"
+
+ // $ANTLR start "RULE_UNARY"
+ public final void mRULE_UNARY() throws RecognitionException {
+ try {
+ int _type = RULE_UNARY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5535:12: ( ( '!' | '~' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5535:14: ( '!' | '~' )
+ {
+ if ( input.LA(1)=='!'||input.LA(1)=='~' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_UNARY"
+
+ // $ANTLR start "RULE_UNTIL"
+ public final void mRULE_UNTIL() throws RecognitionException {
+ try {
+ int _type = RULE_UNTIL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5537:12: ( 'until' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5537:14: 'until'
+ {
+ match("until");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_UNTIL"
+
+ // $ANTLR start "RULE_WHEN"
+ public final void mRULE_WHEN() throws RecognitionException {
+ try {
+ int _type = RULE_WHEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5539:11: ( 'when' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5539:13: 'when'
+ {
+ match("when");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WHEN"
+
+ // $ANTLR start "RULE_WHILE"
+ public final void mRULE_WHILE() throws RecognitionException {
+ try {
+ int _type = RULE_WHILE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5541:12: ( 'while' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5541:14: 'while'
+ {
+ match("while");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WHILE"
+
+ // $ANTLR start "RULE_LOGIC_WORD"
+ public final void mRULE_LOGIC_WORD() throws RecognitionException {
+ try {
+ int _type = RULE_LOGIC_WORD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5543:17: ( ( 'and' | 'or' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5543:19: ( 'and' | 'or' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5543:19: ( 'and' | 'or' )
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0=='a') ) {
+ alt19=1;
+ }
+ else if ( (LA19_0=='o') ) {
+ alt19=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 19, 0, input);
+
+ throw nvae;
+ }
+ switch (alt19) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5543:20: 'and'
+ {
+ match("and");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5543:26: 'or'
+ {
+ match("or");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOGIC_WORD"
+
+ // $ANTLR start "RULE_COMPARE_WORD"
+ public final void mRULE_COMPARE_WORD() throws RecognitionException {
+ try {
+ int _type = RULE_COMPARE_WORD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5545:19: ( ( 'isnt' | 'is' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5545:21: ( 'isnt' | 'is' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5545:21: ( 'isnt' | 'is' )
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0=='i') ) {
+ int LA20_1 = input.LA(2);
+
+ if ( (LA20_1=='s') ) {
+ int LA20_2 = input.LA(3);
+
+ if ( (LA20_2=='n') ) {
+ alt20=1;
+ }
+ else {
+ alt20=2;}
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 20, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 20, 0, input);
+
+ throw nvae;
+ }
+ switch (alt20) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5545:22: 'isnt'
+ {
+ match("isnt");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5545:29: 'is'
+ {
+ match("is");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMPARE_WORD"
+
+ // $ANTLR start "RULE_UNARY_WORD"
+ public final void mRULE_UNARY_WORD() throws RecognitionException {
+ try {
+ int _type = RULE_UNARY_WORD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5547:17: ( ( 'new' | 'do' | 'not' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5547:19: ( 'new' | 'do' | 'not' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5547:19: ( 'new' | 'do' | 'not' )
+ int alt21=3;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0=='n') ) {
+ int LA21_1 = input.LA(2);
+
+ if ( (LA21_1=='e') ) {
+ alt21=1;
+ }
+ else if ( (LA21_1=='o') ) {
+ alt21=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA21_0=='d') ) {
+ alt21=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 0, input);
+
+ throw nvae;
+ }
+ switch (alt21) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5547:20: 'new'
+ {
+ match("new");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5547:26: 'do'
+ {
+ match("do");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5547:31: 'not'
+ {
+ match("not");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_UNARY_WORD"
+
+ // $ANTLR start "RULE_ML_COMMENT"
+ public final void mRULE_ML_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_ML_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5549:17: ( '###' ~ ( '#' ) ( options {greedy=false; } : . )* '###' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5549:19: '###' ~ ( '#' ) ( options {greedy=false; } : . )* '###'
+ {
+ match("###");
+
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\"')||(input.LA(1)>='$' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5549:32: ( options {greedy=false; } : . )*
+ loop22:
+ do {
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( (LA22_0=='#') ) {
+ int LA22_1 = input.LA(2);
+
+ if ( (LA22_1=='#') ) {
+ int LA22_3 = input.LA(3);
+
+ if ( (LA22_3=='#') ) {
+ alt22=2;
+ }
+ else if ( ((LA22_3>='\u0000' && LA22_3<='\"')||(LA22_3>='$' && LA22_3<='\uFFFF')) ) {
+ alt22=1;
+ }
+
+
+ }
+ else if ( ((LA22_1>='\u0000' && LA22_1<='\"')||(LA22_1>='$' && LA22_1<='\uFFFF')) ) {
+ alt22=1;
+ }
+
+
+ }
+ else if ( ((LA22_0>='\u0000' && LA22_0<='\"')||(LA22_0>='$' && LA22_0<='\uFFFF')) ) {
+ alt22=1;
+ }
+
+
+ switch (alt22) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5549:60: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop22;
+ }
+ } while (true);
+
+ match("###");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ML_COMMENT"
+
+ // $ANTLR start "RULE_SL_COMMENT"
+ public final void mRULE_SL_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_SL_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5551:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5551:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+ {
+ match('#');
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5551:23: (~ ( ( '\\n' | '\\r' ) ) )*
+ loop23:
+ do {
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( ((LA23_0>='\u0000' && LA23_0<='\t')||(LA23_0>='\u000B' && LA23_0<='\f')||(LA23_0>='\u000E' && LA23_0<='\uFFFF')) ) {
+ alt23=1;
+ }
+
+
+ switch (alt23) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5551:23: ~ ( ( '\\n' | '\\r' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop23;
+ }
+ } while (true);
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5551:39: ( ( '\\r' )? '\\n' )?
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( (LA25_0=='\n'||LA25_0=='\r') ) {
+ alt25=1;
+ }
+ switch (alt25) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5551:40: ( '\\r' )? '\\n'
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5551:40: ( '\\r' )?
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0=='\r') ) {
+ alt24=1;
+ }
+ switch (alt24) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5551:40: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SL_COMMENT"
+
+ // $ANTLR start "RULE_WS"
+ public final void mRULE_WS() throws RecognitionException {
+ try {
+ int _type = RULE_WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5553:9: ( ( ' ' | '\\t' )+ )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5553:11: ( ' ' | '\\t' )+
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5553:11: ( ' ' | '\\t' )+
+ int cnt26=0;
+ loop26:
+ do {
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0=='\t'||LA26_0==' ') ) {
+ alt26=1;
+ }
+
+
+ switch (alt26) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:
+ {
+ if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt26 >= 1 ) break loop26;
+ EarlyExitException eee =
+ new EarlyExitException(26, input);
+ throw eee;
+ }
+ cnt26++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WS"
+
+ // $ANTLR start "RULE_IDENTIFIER"
+ public final void mRULE_IDENTIFIER() throws RecognitionException {
+ try {
+ int _type = RULE_IDENTIFIER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5555:17: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5555:19: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5555:19: ( '^' )?
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( (LA27_0=='^') ) {
+ alt27=1;
+ }
+ switch (alt27) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5555:19: '^'
+ {
+ match('^');
+
+ }
+ break;
+
+ }
+
+ if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5555:48: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ loop28:
+ do {
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( ((LA28_0>='0' && LA28_0<='9')||(LA28_0>='A' && LA28_0<='Z')||LA28_0=='_'||(LA28_0>='a' && LA28_0<='z')) ) {
+ alt28=1;
+ }
+
+
+ switch (alt28) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop28;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_IDENTIFIER"
+
+ public void mTokens() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:8: ( T__85 | RULE_ELLIPSIS | RULE_DOT_DOT | RULE_DOUBLE_COLON | RULE_SHIFT | RULE_BOUND_FUNC_ARROW | RULE_FUNC_ARROW | RULE_COMPARE | RULE_COMPOUND_ASSIGN | RULE_PLUS_PLUS | RULE_MINUS_MINUS | RULE_PARAM_END | RULE_PARAM_START | RULE_AT_SIGIL | RULE_BOOL | RULE_BY | RULE_CALL_END | RULE_CALL_START | RULE_CATCH | RULE_CLASS | RULE_COLON | RULE_COLON_SLASH | RULE_COMMA | RULE_DOT | RULE_ELSE | RULE_EQUAL | RULE_EXTENDS | RULE_FINALLY | RULE_FOR | RULE_FORIN | RULE_FOROF | RULE_FUNC_EXIST | RULE_HERECOMMENT | RULE_IF | RULE_INDENT | RULE_INDEX_END | RULE_INDEX_PROTO | RULE_INDEX_SOAK | RULE_INDEX_START | RULE_JS | RULE_LBRACKET | RULE_LCURLY | RULE_LEADING_WHEN | RULE_LOGIC | RULE_LOOP | RULE_LPAREN | RULE_MATH | RULE_MINUS | RULE_NEW | RULE_NUMBER | RULE_OUTDENT | RULE_OWN | RULE_PLUS | RULE_POST_IF | RULE_QUESTION | RULE_QUESTION_DOT | RULE_RBRACKET | RULE_RCURLY | RULE_REGEX | RULE_RELATION | RULE_RETURN | RULE_RPAREN | RULE_STATEMENT | RULE_STRING | RULE_SUPER | RULE_SWITCH | RULE_TERMINATOR | RULE_THEN | RULE_THIS | RULE_THROW | RULE_TRY | RULE_UNARY | RULE_UNTIL | RULE_WHEN | RULE_WHILE | RULE_LOGIC_WORD | RULE_COMPARE_WORD | RULE_UNARY_WORD | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_IDENTIFIER )
+ int alt29=82;
+ alt29 = dfa29.predict(input);
+ switch (alt29) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:10: T__85
+ {
+ mT__85();
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:16: RULE_ELLIPSIS
+ {
+ mRULE_ELLIPSIS();
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:30: RULE_DOT_DOT
+ {
+ mRULE_DOT_DOT();
+
+ }
+ break;
+ case 4 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:43: RULE_DOUBLE_COLON
+ {
+ mRULE_DOUBLE_COLON();
+
+ }
+ break;
+ case 5 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:61: RULE_SHIFT
+ {
+ mRULE_SHIFT();
+
+ }
+ break;
+ case 6 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:72: RULE_BOUND_FUNC_ARROW
+ {
+ mRULE_BOUND_FUNC_ARROW();
+
+ }
+ break;
+ case 7 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:94: RULE_FUNC_ARROW
+ {
+ mRULE_FUNC_ARROW();
+
+ }
+ break;
+ case 8 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:110: RULE_COMPARE
+ {
+ mRULE_COMPARE();
+
+ }
+ break;
+ case 9 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:123: RULE_COMPOUND_ASSIGN
+ {
+ mRULE_COMPOUND_ASSIGN();
+
+ }
+ break;
+ case 10 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:144: RULE_PLUS_PLUS
+ {
+ mRULE_PLUS_PLUS();
+
+ }
+ break;
+ case 11 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:159: RULE_MINUS_MINUS
+ {
+ mRULE_MINUS_MINUS();
+
+ }
+ break;
+ case 12 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:176: RULE_PARAM_END
+ {
+ mRULE_PARAM_END();
+
+ }
+ break;
+ case 13 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:191: RULE_PARAM_START
+ {
+ mRULE_PARAM_START();
+
+ }
+ break;
+ case 14 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:208: RULE_AT_SIGIL
+ {
+ mRULE_AT_SIGIL();
+
+ }
+ break;
+ case 15 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:222: RULE_BOOL
+ {
+ mRULE_BOOL();
+
+ }
+ break;
+ case 16 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:232: RULE_BY
+ {
+ mRULE_BY();
+
+ }
+ break;
+ case 17 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:240: RULE_CALL_END
+ {
+ mRULE_CALL_END();
+
+ }
+ break;
+ case 18 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:254: RULE_CALL_START
+ {
+ mRULE_CALL_START();
+
+ }
+ break;
+ case 19 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:270: RULE_CATCH
+ {
+ mRULE_CATCH();
+
+ }
+ break;
+ case 20 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:281: RULE_CLASS
+ {
+ mRULE_CLASS();
+
+ }
+ break;
+ case 21 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:292: RULE_COLON
+ {
+ mRULE_COLON();
+
+ }
+ break;
+ case 22 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:303: RULE_COLON_SLASH
+ {
+ mRULE_COLON_SLASH();
+
+ }
+ break;
+ case 23 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:320: RULE_COMMA
+ {
+ mRULE_COMMA();
+
+ }
+ break;
+ case 24 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:331: RULE_DOT
+ {
+ mRULE_DOT();
+
+ }
+ break;
+ case 25 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:340: RULE_ELSE
+ {
+ mRULE_ELSE();
+
+ }
+ break;
+ case 26 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:350: RULE_EQUAL
+ {
+ mRULE_EQUAL();
+
+ }
+ break;
+ case 27 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:361: RULE_EXTENDS
+ {
+ mRULE_EXTENDS();
+
+ }
+ break;
+ case 28 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:374: RULE_FINALLY
+ {
+ mRULE_FINALLY();
+
+ }
+ break;
+ case 29 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:387: RULE_FOR
+ {
+ mRULE_FOR();
+
+ }
+ break;
+ case 30 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:396: RULE_FORIN
+ {
+ mRULE_FORIN();
+
+ }
+ break;
+ case 31 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:407: RULE_FOROF
+ {
+ mRULE_FOROF();
+
+ }
+ break;
+ case 32 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:418: RULE_FUNC_EXIST
+ {
+ mRULE_FUNC_EXIST();
+
+ }
+ break;
+ case 33 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:434: RULE_HERECOMMENT
+ {
+ mRULE_HERECOMMENT();
+
+ }
+ break;
+ case 34 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:451: RULE_IF
+ {
+ mRULE_IF();
+
+ }
+ break;
+ case 35 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:459: RULE_INDENT
+ {
+ mRULE_INDENT();
+
+ }
+ break;
+ case 36 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:471: RULE_INDEX_END
+ {
+ mRULE_INDEX_END();
+
+ }
+ break;
+ case 37 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:486: RULE_INDEX_PROTO
+ {
+ mRULE_INDEX_PROTO();
+
+ }
+ break;
+ case 38 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:503: RULE_INDEX_SOAK
+ {
+ mRULE_INDEX_SOAK();
+
+ }
+ break;
+ case 39 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:519: RULE_INDEX_START
+ {
+ mRULE_INDEX_START();
+
+ }
+ break;
+ case 40 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:536: RULE_JS
+ {
+ mRULE_JS();
+
+ }
+ break;
+ case 41 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:544: RULE_LBRACKET
+ {
+ mRULE_LBRACKET();
+
+ }
+ break;
+ case 42 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:558: RULE_LCURLY
+ {
+ mRULE_LCURLY();
+
+ }
+ break;
+ case 43 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:570: RULE_LEADING_WHEN
+ {
+ mRULE_LEADING_WHEN();
+
+ }
+ break;
+ case 44 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:588: RULE_LOGIC
+ {
+ mRULE_LOGIC();
+
+ }
+ break;
+ case 45 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:599: RULE_LOOP
+ {
+ mRULE_LOOP();
+
+ }
+ break;
+ case 46 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:609: RULE_LPAREN
+ {
+ mRULE_LPAREN();
+
+ }
+ break;
+ case 47 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:621: RULE_MATH
+ {
+ mRULE_MATH();
+
+ }
+ break;
+ case 48 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:631: RULE_MINUS
+ {
+ mRULE_MINUS();
+
+ }
+ break;
+ case 49 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:642: RULE_NEW
+ {
+ mRULE_NEW();
+
+ }
+ break;
+ case 50 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:651: RULE_NUMBER
+ {
+ mRULE_NUMBER();
+
+ }
+ break;
+ case 51 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:663: RULE_OUTDENT
+ {
+ mRULE_OUTDENT();
+
+ }
+ break;
+ case 52 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:676: RULE_OWN
+ {
+ mRULE_OWN();
+
+ }
+ break;
+ case 53 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:685: RULE_PLUS
+ {
+ mRULE_PLUS();
+
+ }
+ break;
+ case 54 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:695: RULE_POST_IF
+ {
+ mRULE_POST_IF();
+
+ }
+ break;
+ case 55 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:708: RULE_QUESTION
+ {
+ mRULE_QUESTION();
+
+ }
+ break;
+ case 56 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:722: RULE_QUESTION_DOT
+ {
+ mRULE_QUESTION_DOT();
+
+ }
+ break;
+ case 57 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:740: RULE_RBRACKET
+ {
+ mRULE_RBRACKET();
+
+ }
+ break;
+ case 58 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:754: RULE_RCURLY
+ {
+ mRULE_RCURLY();
+
+ }
+ break;
+ case 59 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:766: RULE_REGEX
+ {
+ mRULE_REGEX();
+
+ }
+ break;
+ case 60 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:777: RULE_RELATION
+ {
+ mRULE_RELATION();
+
+ }
+ break;
+ case 61 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:791: RULE_RETURN
+ {
+ mRULE_RETURN();
+
+ }
+ break;
+ case 62 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:803: RULE_RPAREN
+ {
+ mRULE_RPAREN();
+
+ }
+ break;
+ case 63 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:815: RULE_STATEMENT
+ {
+ mRULE_STATEMENT();
+
+ }
+ break;
+ case 64 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:830: RULE_STRING
+ {
+ mRULE_STRING();
+
+ }
+ break;
+ case 65 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:842: RULE_SUPER
+ {
+ mRULE_SUPER();
+
+ }
+ break;
+ case 66 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:853: RULE_SWITCH
+ {
+ mRULE_SWITCH();
+
+ }
+ break;
+ case 67 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:865: RULE_TERMINATOR
+ {
+ mRULE_TERMINATOR();
+
+ }
+ break;
+ case 68 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:881: RULE_THEN
+ {
+ mRULE_THEN();
+
+ }
+ break;
+ case 69 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:891: RULE_THIS
+ {
+ mRULE_THIS();
+
+ }
+ break;
+ case 70 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:901: RULE_THROW
+ {
+ mRULE_THROW();
+
+ }
+ break;
+ case 71 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:912: RULE_TRY
+ {
+ mRULE_TRY();
+
+ }
+ break;
+ case 72 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:921: RULE_UNARY
+ {
+ mRULE_UNARY();
+
+ }
+ break;
+ case 73 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:932: RULE_UNTIL
+ {
+ mRULE_UNTIL();
+
+ }
+ break;
+ case 74 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:943: RULE_WHEN
+ {
+ mRULE_WHEN();
+
+ }
+ break;
+ case 75 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:953: RULE_WHILE
+ {
+ mRULE_WHILE();
+
+ }
+ break;
+ case 76 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:964: RULE_LOGIC_WORD
+ {
+ mRULE_LOGIC_WORD();
+
+ }
+ break;
+ case 77 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:980: RULE_COMPARE_WORD
+ {
+ mRULE_COMPARE_WORD();
+
+ }
+ break;
+ case 78 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:998: RULE_UNARY_WORD
+ {
+ mRULE_UNARY_WORD();
+
+ }
+ break;
+ case 79 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:1014: RULE_ML_COMMENT
+ {
+ mRULE_ML_COMMENT();
+
+ }
+ break;
+ case 80 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:1030: RULE_SL_COMMENT
+ {
+ mRULE_SL_COMMENT();
+
+ }
+ break;
+ case 81 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:1046: RULE_WS
+ {
+ mRULE_WS();
+
+ }
+ break;
+ case 82 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1:1054: RULE_IDENTIFIER
+ {
+ mRULE_IDENTIFIER();
+
+ }
+ break;
+
+ }
+
+ }
+
+
+ protected DFA4 dfa4 = new DFA4(this);
+ protected DFA29 dfa29 = new DFA29(this);
+ static final String DFA4_eotS =
+ "\13\uffff";
+ static final String DFA4_eofS =
+ "\13\uffff";
+ static final String DFA4_minS =
+ "\1\146\3\uffff\1\157\1\146\5\uffff";
+ static final String DFA4_maxS =
+ "\1\171\3\uffff\1\165\1\156\5\uffff";
+ static final String DFA4_acceptS =
+ "\1\uffff\1\1\1\2\1\3\2\uffff\1\7\1\4\1\6\1\5\1\10";
+ static final String DFA4_specialS =
+ "\13\uffff}>";
+ static final String[] DFA4_transitionS = {
+ "\1\2\7\uffff\1\4\1\5\4\uffff\1\1\1\3\3\uffff\1\6",
+ "",
+ "",
+ "",
+ "\1\10\5\uffff\1\7",
+ "\1\12\7\uffff\1\11",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
+ static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
+ static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
+ static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
+ static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
+ static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
+ static final short[][] DFA4_transition;
+
+ static {
+ int numStates = DFA4_transitionS.length;
+ DFA4_transition = new short[numStates][];
+ for (int i=0; i";
+ static final String[] DFA29_transitionS = {
+ "\1\51\1\44\25\uffff\1\51\1\10\1\42\1\50\2\uffff\1\33\1\42\1"+
+ "\13\1\41\1\12\1\11\1\26\1\7\1\2\1\35\12\36\1\3\1\uffff\1\4\1"+
+ "\6\1\5\1\37\1\14\32\52\1\32\1\uffff\1\40\2\52\1\uffff\1\47\1"+
+ "\23\1\24\1\25\1\27\1\16\2\52\1\30\2\52\1\34\1\52\1\20\1\21\2"+
+ "\52\1\1\1\43\1\15\1\17\1\52\1\46\1\52\1\22\1\52\1\31\1\33\1"+
+ "\uffff\1\45",
+ "\1\53",
+ "\1\54",
+ "\1\56",
+ "\1\60",
+ "\1\60",
+ "\1\61\1\62",
+ "\1\66\17\uffff\1\65\1\64",
+ "\1\61",
+ "\1\70\21\uffff\1\65",
+ "\1\73\1\72\62\uffff\1\74\37\uffff\1\75",
+ "\1\77",
+ "",
+ "\1\102\11\uffff\1\101",
+ "\1\103\7\uffff\1\104\5\uffff\1\105",
+ "\1\106",
+ "\1\111\11\uffff\1\110\5\uffff\1\107",
+ "\1\113\7\uffff\1\112\3\uffff\1\115\4\uffff\1\114",
+ "\1\116",
+ "\1\120\6\uffff\1\117",
+ "\1\121\12\uffff\1\122\2\uffff\1\123",
+ "\1\125\11\uffff\1\126\5\uffff\1\124",
+ "",
+ "\1\127\13\uffff\1\130",
+ "\1\132\7\uffff\1\131\4\uffff\1\133",
+ "",
+ "\1\134",
+ "",
+ "\1\136",
+ "\1\137",
+ "",
+ "\1\140",
+ "",
+ "",
+ "",
+ "\1\142\1\uffff\1\143",
+ "",
+ "",
+ "\1\144",
+ "\1\145",
+ "\1\146",
+ "",
+ "",
+ "\1\150\2\uffff\1\151",
+ "\1\152",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\154",
+ "",
+ "\1\156\3\uffff\1\157",
+ "\1\160\3\uffff\1\161\10\uffff\1\162",
+ "\1\163",
+ "\1\164",
+ "\1\165",
+ "\1\166\7\uffff\1\167\7\uffff\1\170",
+ "\1\171",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\23\52\1\172\6\52",
+ "\1\174",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\5\52\1\175\24\52",
+ "\1\177",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0081",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0083",
+ "\1\u0084",
+ "\1\u0085",
+ "\1\u0086",
+ "\1\u0087",
+ "\1\u0088",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u008a",
+ "\1\u008b",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\22\52\1\u008c\7\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\15\52\1\u008f\14"+
+ "\52",
+ "",
+ "",
+ "\1\u0091",
+ "",
+ "",
+ "",
+ "\1\u0092",
+ "\1\u0093",
+ "\1\u0094\3\uffff\1\u0095",
+ "\1\u0096",
+ "\1\u0097",
+ "",
+ "\1\u0098",
+ "\1\u0099",
+ "",
+ "",
+ "",
+ "",
+ "\1\u009a",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u009c",
+ "\1\u009d",
+ "\1\u009e",
+ "\1\u009f",
+ "\1\u00a0",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00a2",
+ "\1\u00a3",
+ "\1\u00a4",
+ "\1\u00a5",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\1\u00a8",
+ "\1\u00a9",
+ "\1\u00aa",
+ "\1\u00ab",
+ "\1\u00ac",
+ "\1\u00ad",
+ "",
+ "\1\u00ae",
+ "\1\u00af",
+ "\1\u00b0",
+ "",
+ "",
+ "\1\u00b1",
+ "",
+ "\1\u00b2",
+ "\1\u00b3",
+ "\1\u00b4",
+ "\1\u00b5",
+ "\1\u00b6",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\u00b9\1\u00b8\2\u00b9\1\u00b7\25\u00b9\1\uffff\uffdc\u00b9",
+ "\1\u00ba",
+ "\1\u00bb",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00be",
+ "\1\u00bf",
+ "\1\u00c0",
+ "",
+ "\1\u00c1",
+ "\1\u00c2",
+ "\1\u00c3",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "",
+ "\1\u00c4",
+ "\1\u00c5",
+ "\1\u00c6",
+ "\1\u00c7",
+ "\1\u00c8",
+ "\1\u00c9",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00cb",
+ "\1\u00cc",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00ce",
+ "\1\u00cf",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00d1",
+ "\12\u00d2\1\u00d3\ufff5\u00d2",
+ "\0\u00d2",
+ "\12\u00d6\1\u00d3\2\u00d6\1\u00d4\25\u00d6\1\u00d5\uffdc\u00d6",
+ "\1\u00d7",
+ "\1\u00d8",
+ "",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00da",
+ "\1\u00db",
+ "\1\u00dc",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00e1",
+ "\1\u00e2",
+ "\1\u00e3",
+ "",
+ "\1\u00e4",
+ "\1\u00e5",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00e7",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\0\u00d2",
+ "\12\u00d2\1\u00d3\ufff5\u00d2",
+ "\12\u00d6\1\u00d3\2\u00d6\1\u00d4\25\u00d6\1\u00e9\uffdc\u00d6",
+ "\12\u00d6\1\u00d3\2\u00d6\1\u00d4\25\u00d6\1\u00d5\uffdc\u00d6",
+ "\1\u00ea",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\1\u00ec",
+ "\1\u00ed",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "",
+ "",
+ "",
+ "\1\u00ee",
+ "\1\u00ef\2\uffff\1\u00f0\1\uffff\1\u00f1\1\u00f2\1\u00f3\1"+
+ "\uffff\1\u00f4\3\uffff\1\u00f5\1\uffff\1\u00f6",
+ "\1\u00f7",
+ "\1\u00f8",
+ "\1\u00f9",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\u00d6\1\u00d3\2\u00d6\1\u00d4\25\u00d6\1\u00fb\uffdc\u00d6",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00fe",
+ "\1\u00ff",
+ "",
+ "",
+ "",
+ "\1\u0100",
+ "",
+ "\1\u0101\1\uffff\1\u0102",
+ "",
+ "",
+ "\1\u0103",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0105",
+ "",
+ "\12\u00d6\1\u00d3\2\u00d6\1\u00d4\25\u00d6\1\u00fb\uffdc\u00d6",
+ "",
+ "",
+ "\1\u0106",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0107",
+ "",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\1\u0108",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0109",
+ "\1\u010a",
+ "\1\u010b",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u010d",
+ "",
+ "\1\u010e\2\uffff\1\u010f",
+ "",
+ ""
+ };
+
+ static final short[] DFA29_eot = DFA.unpackEncodedString(DFA29_eotS);
+ static final short[] DFA29_eof = DFA.unpackEncodedString(DFA29_eofS);
+ static final char[] DFA29_min = DFA.unpackEncodedStringToUnsignedChars(DFA29_minS);
+ static final char[] DFA29_max = DFA.unpackEncodedStringToUnsignedChars(DFA29_maxS);
+ static final short[] DFA29_accept = DFA.unpackEncodedString(DFA29_acceptS);
+ static final short[] DFA29_special = DFA.unpackEncodedString(DFA29_specialS);
+ static final short[][] DFA29_transition;
+
+ static {
+ int numStates = DFA29_transitionS.length;
+ DFA29_transition = new short[numStates][];
+ for (int i=0; i='\u0000' && LA29_214<='\t')||(LA29_214>='\u000B' && LA29_214<='\f')||(LA29_214>='\u000E' && LA29_214<='\"')||(LA29_214>='$' && LA29_214<='\uFFFF')) ) {s = 214;}
+
+ else s = 103;
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA29_184 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_184>='\u0000' && LA29_184<='\uFFFF')) ) {s = 210;}
+
+ else s = 103;
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA29_233 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_233=='#') ) {s = 251;}
+
+ else if ( (LA29_233=='\r') ) {s = 212;}
+
+ else if ( (LA29_233=='\n') ) {s = 211;}
+
+ else if ( ((LA29_233>='\u0000' && LA29_233<='\t')||(LA29_233>='\u000B' && LA29_233<='\f')||(LA29_233>='\u000E' && LA29_233<='\"')||(LA29_233>='$' && LA29_233<='\uFFFF')) ) {s = 214;}
+
+ else s = 103;
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA29_185 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_185=='\r') ) {s = 212;}
+
+ else if ( (LA29_185=='\n') ) {s = 211;}
+
+ else if ( (LA29_185=='#') ) {s = 213;}
+
+ else if ( ((LA29_185>='\u0000' && LA29_185<='\t')||(LA29_185>='\u000B' && LA29_185<='\f')||(LA29_185>='\u000E' && LA29_185<='\"')||(LA29_185>='$' && LA29_185<='\uFFFF')) ) {s = 214;}
+
+ else s = 103;
+
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA29_183 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_183>='\u0000' && LA29_183<='\t')||(LA29_183>='\u000B' && LA29_183<='\uFFFF')) ) {s = 210;}
+
+ else if ( (LA29_183=='\n') ) {s = 211;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA29_213 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_213=='#') ) {s = 233;}
+
+ else if ( (LA29_213=='\r') ) {s = 212;}
+
+ else if ( (LA29_213=='\n') ) {s = 211;}
+
+ else if ( ((LA29_213>='\u0000' && LA29_213<='\t')||(LA29_213>='\u000B' && LA29_213<='\f')||(LA29_213>='\u000E' && LA29_213<='\"')||(LA29_213>='$' && LA29_213<='\uFFFF')) ) {s = 214;}
+
+ else s = 103;
+
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA29_212 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_212>='\u0000' && LA29_212<='\t')||(LA29_212>='\u000B' && LA29_212<='\uFFFF')) ) {s = 210;}
+
+ else if ( (LA29_212=='\n') ) {s = 211;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA29_151 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_151=='\r') ) {s = 183;}
+
+ else if ( (LA29_151=='\n') ) {s = 184;}
+
+ else if ( ((LA29_151>='\u0000' && LA29_151<='\t')||(LA29_151>='\u000B' && LA29_151<='\f')||(LA29_151>='\u000E' && LA29_151<='\"')||(LA29_151>='$' && LA29_151<='\uFFFF')) ) {s = 185;}
+
+ else s = 103;
+
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA29_251 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_251=='#') ) {s = 251;}
+
+ else if ( (LA29_251=='\r') ) {s = 212;}
+
+ else if ( (LA29_251=='\n') ) {s = 211;}
+
+ else if ( ((LA29_251>='\u0000' && LA29_251<='\t')||(LA29_251>='\u000B' && LA29_251<='\f')||(LA29_251>='\u000E' && LA29_251<='\"')||(LA29_251>='$' && LA29_251<='\uFFFF')) ) {s = 214;}
+
+ else s = 210;
+
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA29_211 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_211>='\u0000' && LA29_211<='\uFFFF')) ) {s = 210;}
+
+ else s = 103;
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 29, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScriptParser.java b/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScriptParser.java
new file mode 100644
index 0000000..96a5ccb
--- /dev/null
+++ b/csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScriptParser.java
@@ -0,0 +1,18771 @@
+package csep.parser.antlr.internal;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import csep.services.CoffeeScriptGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+@SuppressWarnings("all")
+public class InternalCoffeeScriptParser extends AbstractInternalAntlrParser {
+ public static final String[] tokenNames = new String[] {
+ "", "", "", "", "RULE_TERMINATOR", "RULE_STATEMENT", "RULE_HERECOMMENT", "RULE_EQUAL", "RULE_CALL_START", "RULE_STRING", "RULE_CALL_END", "RULE_RETURN", "RULE_POST_IF", "RULE_THROW", "RULE_CLASS", "RULE_EXTENDS", "RULE_FOR", "RULE_WHILE", "RULE_WHEN", "RULE_UNTIL", "RULE_OWN", "RULE_COMMA", "RULE_FOROF", "RULE_FORIN", "RULE_BY", "RULE_LBRACKET", "RULE_DOT_DOT", "RULE_ELLIPSIS", "RULE_RBRACKET", "RULE_COMPOUND_ASSIGN", "RULE_INDENT", "RULE_OUTDENT", "RULE_LOGIC", "RULE_COMPARE", "RULE_RELATION", "RULE_SHIFT", "RULE_PLUS", "RULE_MINUS", "RULE_MATH", "RULE_UNARY", "RULE_PLUS_PLUS", "RULE_MINUS_MINUS", "RULE_QUESTION", "RULE_SUPER", "RULE_FUNC_EXIST", "RULE_AT_SIGIL", "RULE_DOT", "RULE_QUESTION_DOT", "RULE_DOUBLE_COLON", "RULE_INDEX_START", "RULE_INDEX_END", "RULE_THIS", "RULE_LOOP", "RULE_TRY", "RULE_CATCH", "RULE_FINALLY", "RULE_SWITCH", "RULE_ELSE", "RULE_LEADING_WHEN", "RULE_IF", "RULE_IDENTIFIER", "RULE_LCURLY", "RULE_RCURLY", "RULE_COLON", "RULE_PARAM_START", "RULE_PARAM_END", "RULE_FUNC_ARROW", "RULE_BOUND_FUNC_ARROW", "RULE_NUMBER", "RULE_BOOL", "RULE_JS", "RULE_REGEX", "RULE_LPAREN", "RULE_RPAREN", "RULE_COLON_SLASH", "RULE_INDEX_PROTO", "RULE_INDEX_SOAK", "RULE_NEW", "RULE_THEN", "RULE_LOGIC_WORD", "RULE_COMPARE_WORD", "RULE_UNARY_WORD", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "'require'"
+ };
+ public static final int RULE_BOUND_FUNC_ARROW=67;
+ public static final int RULE_SWITCH=56;
+ public static final int RULE_THROW=13;
+ public static final int RULE_PARAM_START=64;
+ public static final int RULE_TERMINATOR=4;
+ public static final int RULE_CALL_END=10;
+ public static final int RULE_RETURN=11;
+ public static final int RULE_FOR=16;
+ public static final int RULE_BOOL=69;
+ public static final int RULE_LBRACKET=25;
+ public static final int RULE_DOUBLE_COLON=48;
+ public static final int RULE_MINUS_MINUS=41;
+ public static final int RULE_COMPARE_WORD=80;
+ public static final int EOF=-1;
+ public static final int RULE_OUTDENT=31;
+ public static final int RULE_RELATION=34;
+ public static final int RULE_REGEX=71;
+ public static final int RULE_CLASS=14;
+ public static final int RULE_WHILE=17;
+ public static final int RULE_COLON_SLASH=74;
+ public static final int RULE_FUNC_EXIST=44;
+ public static final int RULE_DOT=46;
+ public static final int RULE_POST_IF=12;
+ public static final int RULE_PLUS_PLUS=40;
+ public static final int RULE_OWN=20;
+ public static final int RULE_NUMBER=68;
+ public static final int RULE_LOOP=52;
+ public static final int RULE_LPAREN=72;
+ public static final int RULE_FUNC_ARROW=66;
+ public static final int RULE_AT_SIGIL=45;
+ public static final int RULE_EXTENDS=15;
+ public static final int RULE_SHIFT=35;
+ public static final int RULE_INDEX_END=50;
+ public static final int RULE_COMPARE=33;
+ public static final int RULE_QUESTION_DOT=47;
+ public static final int RULE_RBRACKET=28;
+ public static final int RULE_COMPOUND_ASSIGN=29;
+ public static final int RULE_SUPER=43;
+ public static final int RULE_THEN=78;
+ public static final int RULE_UNARY_WORD=81;
+ public static final int RULE_LEADING_WHEN=58;
+ public static final int RULE_DOT_DOT=26;
+ public static final int RULE_STATEMENT=5;
+ public static final int RULE_PLUS=36;
+ public static final int RULE_BY=24;
+ public static final int RULE_INDEX_SOAK=76;
+ public static final int RULE_CATCH=54;
+ public static final int RULE_CALL_START=8;
+ public static final int RULE_INDEX_PROTO=75;
+ public static final int RULE_IDENTIFIER=60;
+ public static final int RULE_COMMA=21;
+ public static final int RULE_TRY=53;
+ public static final int RULE_JS=70;
+ public static final int RULE_EQUAL=7;
+ public static final int RULE_INDENT=30;
+ public static final int RULE_HERECOMMENT=6;
+ public static final int RULE_FORIN=23;
+ public static final int RULE_ELLIPSIS=27;
+ public static final int T__85=85;
+ public static final int RULE_SL_COMMENT=83;
+ public static final int RULE_PARAM_END=65;
+ public static final int RULE_ML_COMMENT=82;
+ public static final int RULE_WHEN=18;
+ public static final int RULE_INDEX_START=49;
+ public static final int RULE_COLON=63;
+ public static final int RULE_MINUS=37;
+ public static final int RULE_STRING=9;
+ public static final int RULE_NEW=77;
+ public static final int RULE_LOGIC_WORD=79;
+ public static final int RULE_LOGIC=32;
+ public static final int RULE_RPAREN=73;
+ public static final int RULE_WS=84;
+ public static final int RULE_FOROF=22;
+ public static final int RULE_IF=59;
+ public static final int RULE_THIS=51;
+ public static final int RULE_UNARY=39;
+ public static final int RULE_RCURLY=62;
+ public static final int RULE_ELSE=57;
+ public static final int RULE_FINALLY=55;
+ public static final int RULE_MATH=38;
+ public static final int RULE_LCURLY=61;
+ public static final int RULE_UNTIL=19;
+ public static final int RULE_QUESTION=42;
+
+ // delegates
+ // delegators
+
+
+ public InternalCoffeeScriptParser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalCoffeeScriptParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+
+ }
+
+
+ public String[] getTokenNames() { return InternalCoffeeScriptParser.tokenNames; }
+ public String getGrammarFileName() { return "../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g"; }
+
+
+
+ private CoffeeScriptGrammarAccess grammarAccess;
+
+ public InternalCoffeeScriptParser(TokenStream input, CoffeeScriptGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "Root";
+ }
+
+ @Override
+ protected CoffeeScriptGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+
+
+
+ // $ANTLR start "entryRuleRoot"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:67:1: entryRuleRoot returns [EObject current=null] : iv_ruleRoot= ruleRoot EOF ;
+ public final EObject entryRuleRoot() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRoot = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:68:2: (iv_ruleRoot= ruleRoot EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:69:2: iv_ruleRoot= ruleRoot EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getRootRule());
+ }
+ pushFollow(FOLLOW_ruleRoot_in_entryRuleRoot75);
+ iv_ruleRoot=ruleRoot();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleRoot;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRoot85); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRoot"
+
+
+ // $ANTLR start "ruleRoot"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:76:1: ruleRoot returns [EObject current=null] : (this_Body_0= ruleBody | (this_Block_1= ruleBlock this_TERMINATOR_2= RULE_TERMINATOR ) )? ;
+ public final EObject ruleRoot() throws RecognitionException {
+ EObject current = null;
+
+ Token this_TERMINATOR_2=null;
+ EObject this_Body_0 = null;
+
+ EObject this_Block_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:79:28: ( (this_Body_0= ruleBody | (this_Block_1= ruleBlock this_TERMINATOR_2= RULE_TERMINATOR ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:80:1: (this_Body_0= ruleBody | (this_Block_1= ruleBlock this_TERMINATOR_2= RULE_TERMINATOR ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:80:1: (this_Body_0= ruleBody | (this_Block_1= ruleBlock this_TERMINATOR_2= RULE_TERMINATOR ) )?
+ int alt1=3;
+ int LA1_0 = input.LA(1);
+
+ if ( ((LA1_0>=RULE_STATEMENT && LA1_0<=RULE_HERECOMMENT)||LA1_0==RULE_STRING||LA1_0==RULE_RETURN||(LA1_0>=RULE_THROW && LA1_0<=RULE_CLASS)||(LA1_0>=RULE_FOR && LA1_0<=RULE_WHILE)||LA1_0==RULE_UNTIL||LA1_0==RULE_LBRACKET||(LA1_0>=RULE_PLUS && LA1_0<=RULE_MINUS)||(LA1_0>=RULE_UNARY && LA1_0<=RULE_MINUS_MINUS)||LA1_0==RULE_SUPER||LA1_0==RULE_AT_SIGIL||(LA1_0>=RULE_THIS && LA1_0<=RULE_TRY)||LA1_0==RULE_SWITCH||(LA1_0>=RULE_IF && LA1_0<=RULE_LCURLY)||LA1_0==RULE_PARAM_START||(LA1_0>=RULE_FUNC_ARROW && LA1_0<=RULE_LPAREN)) ) {
+ alt1=1;
+ }
+ else if ( (LA1_0==RULE_INDENT) ) {
+ alt1=2;
+ }
+ switch (alt1) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:81:5: this_Body_0= ruleBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRootAccess().getBodyParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleBody_in_ruleRoot132);
+ this_Body_0=ruleBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Body_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:90:6: (this_Block_1= ruleBlock this_TERMINATOR_2= RULE_TERMINATOR )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:90:6: (this_Block_1= ruleBlock this_TERMINATOR_2= RULE_TERMINATOR )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:91:5: this_Block_1= ruleBlock this_TERMINATOR_2= RULE_TERMINATOR
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRootAccess().getBlockParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleRoot160);
+ this_Block_1=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Block_1;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_TERMINATOR_2=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleRoot170); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_2, grammarAccess.getRootAccess().getTERMINATORTerminalRuleCall_1_1());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRoot"
+
+
+ // $ANTLR start "entryRuleBody"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:111:1: entryRuleBody returns [EObject current=null] : iv_ruleBody= ruleBody EOF ;
+ public final EObject entryRuleBody() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleBody = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:112:2: (iv_ruleBody= ruleBody EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:113:2: iv_ruleBody= ruleBody EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getBodyRule());
+ }
+ pushFollow(FOLLOW_ruleBody_in_entryRuleBody207);
+ iv_ruleBody=ruleBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleBody;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBody217); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleBody"
+
+
+ // $ANTLR start "ruleBody"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:120:1: ruleBody returns [EObject current=null] : ( ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )* ) ;
+ public final EObject ruleBody() throws RecognitionException {
+ EObject current = null;
+
+ Token this_TERMINATOR_1=null;
+ EObject lv_lines_0_0 = null;
+
+ EObject lv_lines_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:123:28: ( ( ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:124:1: ( ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:124:1: ( ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:124:2: ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )*
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:124:2: ( (lv_lines_0_0= ruleLine ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:125:1: (lv_lines_0_0= ruleLine )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:125:1: (lv_lines_0_0= ruleLine )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:126:3: lv_lines_0_0= ruleLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleLine_in_ruleBody263);
+ lv_lines_0_0=ruleLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getBodyRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_0_0,
+ "Line");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:142:2: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )*
+ loop3:
+ do {
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0==RULE_TERMINATOR) ) {
+ alt3=1;
+ }
+
+
+ switch (alt3) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:142:3: this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )?
+ {
+ this_TERMINATOR_1=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleBody275); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:146:1: ( (lv_lines_2_0= ruleLine ) )?
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( ((LA2_0>=RULE_STATEMENT && LA2_0<=RULE_HERECOMMENT)||LA2_0==RULE_STRING||LA2_0==RULE_RETURN||(LA2_0>=RULE_THROW && LA2_0<=RULE_CLASS)||(LA2_0>=RULE_FOR && LA2_0<=RULE_WHILE)||LA2_0==RULE_UNTIL||LA2_0==RULE_LBRACKET||(LA2_0>=RULE_PLUS && LA2_0<=RULE_MINUS)||(LA2_0>=RULE_UNARY && LA2_0<=RULE_MINUS_MINUS)||LA2_0==RULE_SUPER||LA2_0==RULE_AT_SIGIL||(LA2_0>=RULE_THIS && LA2_0<=RULE_TRY)||LA2_0==RULE_SWITCH||(LA2_0>=RULE_IF && LA2_0<=RULE_LCURLY)||LA2_0==RULE_PARAM_START||(LA2_0>=RULE_FUNC_ARROW && LA2_0<=RULE_LPAREN)) ) {
+ alt2=1;
+ }
+ switch (alt2) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:147:1: (lv_lines_2_0= ruleLine )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:147:1: (lv_lines_2_0= ruleLine )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:148:3: lv_lines_2_0= ruleLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleLine_in_ruleBody295);
+ lv_lines_2_0=ruleLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getBodyRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_2_0,
+ "Line");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop3;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleBody"
+
+
+ // $ANTLR start "entryRuleLine"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:172:1: entryRuleLine returns [EObject current=null] : iv_ruleLine= ruleLine EOF ;
+ public final EObject entryRuleLine() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleLine = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:173:2: (iv_ruleLine= ruleLine EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:174:2: iv_ruleLine= ruleLine EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getLineRule());
+ }
+ pushFollow(FOLLOW_ruleLine_in_entryRuleLine334);
+ iv_ruleLine=ruleLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleLine;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLine344); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleLine"
+
+
+ // $ANTLR start "ruleLine"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:181:1: ruleLine returns [EObject current=null] : (this_Stmt_0= ruleStmt | this_Expression_1= ruleExpression ) ;
+ public final EObject ruleLine() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Stmt_0 = null;
+
+ EObject this_Expression_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:184:28: ( (this_Stmt_0= ruleStmt | this_Expression_1= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:185:1: (this_Stmt_0= ruleStmt | this_Expression_1= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:185:1: (this_Stmt_0= ruleStmt | this_Expression_1= ruleExpression )
+ int alt4=2;
+ switch ( input.LA(1) ) {
+ case RULE_STATEMENT:
+ case RULE_HERECOMMENT:
+ case RULE_RETURN:
+ case RULE_THROW:
+ case RULE_CLASS:
+ {
+ alt4=1;
+ }
+ break;
+ case RULE_IDENTIFIER:
+ {
+ int LA4_2 = input.LA(2);
+
+ if ( (LA4_2==EOF||LA4_2==RULE_TERMINATOR||LA4_2==RULE_CALL_START||LA4_2==RULE_POST_IF||(LA4_2>=RULE_FOR && LA4_2<=RULE_WHILE)||LA4_2==RULE_UNTIL||LA4_2==RULE_COMPOUND_ASSIGN||(LA4_2>=RULE_OUTDENT && LA4_2<=RULE_MATH)||LA4_2==RULE_QUESTION||LA4_2==RULE_FUNC_EXIST||(LA4_2>=RULE_DOT && LA4_2<=RULE_INDEX_START)||LA4_2==RULE_RPAREN) ) {
+ alt4=2;
+ }
+ else if ( (LA4_2==RULE_EQUAL) ) {
+ int LA4_4 = input.LA(3);
+
+ if ( (LA4_4==RULE_STRING||LA4_4==RULE_CLASS||(LA4_4>=RULE_FOR && LA4_4<=RULE_WHILE)||LA4_4==RULE_UNTIL||LA4_4==RULE_LBRACKET||LA4_4==RULE_INDENT||(LA4_4>=RULE_PLUS && LA4_4<=RULE_MINUS)||(LA4_4>=RULE_UNARY && LA4_4<=RULE_MINUS_MINUS)||LA4_4==RULE_SUPER||LA4_4==RULE_AT_SIGIL||(LA4_4>=RULE_THIS && LA4_4<=RULE_TRY)||LA4_4==RULE_SWITCH||(LA4_4>=RULE_IF && LA4_4<=RULE_LCURLY)||LA4_4==RULE_PARAM_START||(LA4_4>=RULE_FUNC_ARROW && LA4_4<=RULE_LPAREN)) ) {
+ alt4=2;
+ }
+ else if ( (LA4_4==85) ) {
+ alt4=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 4, 4, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 4, 2, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case RULE_STRING:
+ case RULE_FOR:
+ case RULE_WHILE:
+ case RULE_UNTIL:
+ case RULE_LBRACKET:
+ case RULE_PLUS:
+ case RULE_MINUS:
+ case RULE_UNARY:
+ case RULE_PLUS_PLUS:
+ case RULE_MINUS_MINUS:
+ case RULE_SUPER:
+ case RULE_AT_SIGIL:
+ case RULE_THIS:
+ case RULE_LOOP:
+ case RULE_TRY:
+ case RULE_SWITCH:
+ case RULE_IF:
+ case RULE_LCURLY:
+ case RULE_PARAM_START:
+ case RULE_FUNC_ARROW:
+ case RULE_BOUND_FUNC_ARROW:
+ case RULE_NUMBER:
+ case RULE_BOOL:
+ case RULE_JS:
+ case RULE_REGEX:
+ case RULE_LPAREN:
+ {
+ alt4=2;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 4, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt4) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:186:5: this_Stmt_0= ruleStmt
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLineAccess().getStmtParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleStmt_in_ruleLine391);
+ this_Stmt_0=ruleStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Stmt_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:196:5: this_Expression_1= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLineAccess().getExpressionParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleLine418);
+ this_Expression_1=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Expression_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleLine"
+
+
+ // $ANTLR start "entryRuleStmt"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:212:1: entryRuleStmt returns [EObject current=null] : iv_ruleStmt= ruleStmt EOF ;
+ public final EObject entryRuleStmt() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleStmt = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:213:2: (iv_ruleStmt= ruleStmt EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:214:2: iv_ruleStmt= ruleStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getStmtRule());
+ }
+ pushFollow(FOLLOW_ruleStmt_in_entryRuleStmt453);
+ iv_ruleStmt=ruleStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleStmt;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleStmt463); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleStmt"
+
+
+ // $ANTLR start "ruleStmt"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:221:1: ruleStmt returns [EObject current=null] : (this_ReturnStmt_0= ruleReturnStmt | this_ThrowStmt_1= ruleThrowStmt | ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt ) | this_Comment_3= ruleComment | this_ClassDeclaration_4= ruleClassDeclaration | ( (lv_statement_5_0= RULE_STATEMENT ) ) ) ;
+ public final EObject ruleStmt() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_statement_5_0=null;
+ EObject this_ReturnStmt_0 = null;
+
+ EObject this_ThrowStmt_1 = null;
+
+ EObject this_RequireStmt_2 = null;
+
+ EObject this_Comment_3 = null;
+
+ EObject this_ClassDeclaration_4 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:224:28: ( (this_ReturnStmt_0= ruleReturnStmt | this_ThrowStmt_1= ruleThrowStmt | ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt ) | this_Comment_3= ruleComment | this_ClassDeclaration_4= ruleClassDeclaration | ( (lv_statement_5_0= RULE_STATEMENT ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:225:1: (this_ReturnStmt_0= ruleReturnStmt | this_ThrowStmt_1= ruleThrowStmt | ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt ) | this_Comment_3= ruleComment | this_ClassDeclaration_4= ruleClassDeclaration | ( (lv_statement_5_0= RULE_STATEMENT ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:225:1: (this_ReturnStmt_0= ruleReturnStmt | this_ThrowStmt_1= ruleThrowStmt | ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt ) | this_Comment_3= ruleComment | this_ClassDeclaration_4= ruleClassDeclaration | ( (lv_statement_5_0= RULE_STATEMENT ) ) )
+ int alt5=6;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0==RULE_RETURN) ) {
+ alt5=1;
+ }
+ else if ( (LA5_0==RULE_THROW) ) {
+ alt5=2;
+ }
+ else if ( (LA5_0==RULE_IDENTIFIER) && (synpred1_InternalCoffeeScript())) {
+ alt5=3;
+ }
+ else if ( (LA5_0==RULE_HERECOMMENT) ) {
+ alt5=4;
+ }
+ else if ( (LA5_0==RULE_CLASS) ) {
+ alt5=5;
+ }
+ else if ( (LA5_0==RULE_STATEMENT) ) {
+ alt5=6;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 5, 0, input);
+
+ throw nvae;
+ }
+ switch (alt5) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:226:5: this_ReturnStmt_0= ruleReturnStmt
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleReturnStmt_in_ruleStmt510);
+ this_ReturnStmt_0=ruleReturnStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ReturnStmt_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:236:5: this_ThrowStmt_1= ruleThrowStmt
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleThrowStmt_in_ruleStmt537);
+ this_ThrowStmt_1=ruleThrowStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ThrowStmt_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:245:6: ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:245:6: ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:245:7: ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleRequireStmt_in_ruleStmt585);
+ this_RequireStmt_2=ruleRequireStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_RequireStmt_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:261:5: this_Comment_3= ruleComment
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getCommentParserRuleCall_3());
+
+ }
+ pushFollow(FOLLOW_ruleComment_in_ruleStmt613);
+ this_Comment_3=ruleComment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Comment_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 5 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:271:5: this_ClassDeclaration_4= ruleClassDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4());
+
+ }
+ pushFollow(FOLLOW_ruleClassDeclaration_in_ruleStmt640);
+ this_ClassDeclaration_4=ruleClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ClassDeclaration_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 6 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:280:6: ( (lv_statement_5_0= RULE_STATEMENT ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:280:6: ( (lv_statement_5_0= RULE_STATEMENT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:281:1: (lv_statement_5_0= RULE_STATEMENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:281:1: (lv_statement_5_0= RULE_STATEMENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:282:3: lv_statement_5_0= RULE_STATEMENT
+ {
+ lv_statement_5_0=(Token)match(input,RULE_STATEMENT,FOLLOW_RULE_STATEMENT_in_ruleStmt662); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_statement_5_0, grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getStmtRule());
+ }
+ setWithLastConsumed(
+ current,
+ "statement",
+ lv_statement_5_0,
+ "STATEMENT");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleStmt"
+
+
+ // $ANTLR start "entryRuleComment"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:306:1: entryRuleComment returns [EObject current=null] : iv_ruleComment= ruleComment EOF ;
+ public final EObject entryRuleComment() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleComment = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:307:2: (iv_ruleComment= ruleComment EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:308:2: iv_ruleComment= ruleComment EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getCommentRule());
+ }
+ pushFollow(FOLLOW_ruleComment_in_entryRuleComment703);
+ iv_ruleComment=ruleComment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleComment;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleComment713); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleComment"
+
+
+ // $ANTLR start "ruleComment"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:315:1: ruleComment returns [EObject current=null] : ( (lv_comment_0_0= RULE_HERECOMMENT ) ) ;
+ public final EObject ruleComment() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_comment_0_0=null;
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:318:28: ( ( (lv_comment_0_0= RULE_HERECOMMENT ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:319:1: ( (lv_comment_0_0= RULE_HERECOMMENT ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:319:1: ( (lv_comment_0_0= RULE_HERECOMMENT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:320:1: (lv_comment_0_0= RULE_HERECOMMENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:320:1: (lv_comment_0_0= RULE_HERECOMMENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:321:3: lv_comment_0_0= RULE_HERECOMMENT
+ {
+ lv_comment_0_0=(Token)match(input,RULE_HERECOMMENT,FOLLOW_RULE_HERECOMMENT_in_ruleComment754); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_comment_0_0, grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getCommentRule());
+ }
+ setWithLastConsumed(
+ current,
+ "comment",
+ lv_comment_0_0,
+ "HERECOMMENT");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleComment"
+
+
+ // $ANTLR start "entryRuleRequireStmt"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:345:1: entryRuleRequireStmt returns [EObject current=null] : iv_ruleRequireStmt= ruleRequireStmt EOF ;
+ public final EObject entryRuleRequireStmt() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRequireStmt = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:346:2: (iv_ruleRequireStmt= ruleRequireStmt EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:347:2: iv_ruleRequireStmt= ruleRequireStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getRequireStmtRule());
+ }
+ pushFollow(FOLLOW_ruleRequireStmt_in_entryRuleRequireStmt794);
+ iv_ruleRequireStmt=ruleRequireStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleRequireStmt;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRequireStmt804); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRequireStmt"
+
+
+ // $ANTLR start "ruleRequireStmt"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:354:1: ruleRequireStmt returns [EObject current=null] : ( ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END ) ;
+ public final EObject ruleRequireStmt() throws RecognitionException {
+ EObject current = null;
+
+ Token this_EQUAL_1=null;
+ Token otherlv_2=null;
+ Token this_CALL_START_3=null;
+ Token lv_uri_4_0=null;
+ Token this_CALL_END_5=null;
+ EObject lv_importedNamespace_0_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:357:28: ( ( ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:358:1: ( ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:358:1: ( ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:358:2: ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:358:2: ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:358:3: ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:363:5: ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:363:6: ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require'
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:363:6: ( (lv_importedNamespace_0_0= ruleId ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:364:1: (lv_importedNamespace_0_0= ruleId )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:364:1: (lv_importedNamespace_0_0= ruleId )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:365:3: lv_importedNamespace_0_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleRequireStmt872);
+ lv_importedNamespace_0_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRequireStmtRule());
+ }
+ set(
+ current,
+ "importedNamespace",
+ lv_importedNamespace_0_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_EQUAL_1=(Token)match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_ruleRequireStmt883); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EQUAL_1, grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1());
+
+ }
+ otherlv_2=(Token)match(input,85,FOLLOW_85_in_ruleRequireStmt894); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2());
+
+ }
+
+ }
+
+
+ }
+
+ this_CALL_START_3=(Token)match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_ruleRequireStmt907); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_START_3, grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:393:1: ( (lv_uri_4_0= RULE_STRING ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:394:1: (lv_uri_4_0= RULE_STRING )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:394:1: (lv_uri_4_0= RULE_STRING )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:395:3: lv_uri_4_0= RULE_STRING
+ {
+ lv_uri_4_0=(Token)match(input,RULE_STRING,FOLLOW_RULE_STRING_in_ruleRequireStmt923); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_uri_4_0, grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRequireStmtRule());
+ }
+ setWithLastConsumed(
+ current,
+ "uri",
+ lv_uri_4_0,
+ "STRING");
+
+ }
+
+ }
+
+
+ }
+
+ this_CALL_END_5=(Token)match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_ruleRequireStmt939); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_END_5, grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRequireStmt"
+
+
+ // $ANTLR start "entryRuleReturnStmt"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:423:1: entryRuleReturnStmt returns [EObject current=null] : iv_ruleReturnStmt= ruleReturnStmt EOF ;
+ public final EObject entryRuleReturnStmt() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleReturnStmt = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:424:2: (iv_ruleReturnStmt= ruleReturnStmt EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:425:2: iv_ruleReturnStmt= ruleReturnStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getReturnStmtRule());
+ }
+ pushFollow(FOLLOW_ruleReturnStmt_in_entryRuleReturnStmt974);
+ iv_ruleReturnStmt=ruleReturnStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleReturnStmt;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleReturnStmt984); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleReturnStmt"
+
+
+ // $ANTLR start "ruleReturnStmt"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:432:1: ruleReturnStmt returns [EObject current=null] : ( () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )? ) ;
+ public final EObject ruleReturnStmt() throws RecognitionException {
+ EObject current = null;
+
+ Token this_RETURN_1=null;
+ Token this_POST_IF_3=null;
+ EObject lv_expression_2_0 = null;
+
+ EObject lv_condition_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:435:28: ( ( () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:436:1: ( () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:436:1: ( () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:436:2: () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:436:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:437:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getReturnStmtAccess().getReturnStmtAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_RETURN_1=(Token)match(input,RULE_RETURN,FOLLOW_RULE_RETURN_in_ruleReturnStmt1029); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RETURN_1, grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:446:1: ( (lv_expression_2_0= ruleExpression ) )?
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0==RULE_STRING||(LA6_0>=RULE_FOR && LA6_0<=RULE_WHILE)||LA6_0==RULE_UNTIL||LA6_0==RULE_LBRACKET||(LA6_0>=RULE_PLUS && LA6_0<=RULE_MINUS)||(LA6_0>=RULE_UNARY && LA6_0<=RULE_MINUS_MINUS)||LA6_0==RULE_SUPER||LA6_0==RULE_AT_SIGIL||(LA6_0>=RULE_THIS && LA6_0<=RULE_TRY)||LA6_0==RULE_SWITCH||(LA6_0>=RULE_IF && LA6_0<=RULE_LCURLY)||LA6_0==RULE_PARAM_START||(LA6_0>=RULE_FUNC_ARROW && LA6_0<=RULE_LPAREN)) ) {
+ alt6=1;
+ }
+ switch (alt6) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:447:1: (lv_expression_2_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:447:1: (lv_expression_2_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:448:3: lv_expression_2_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleReturnStmt1049);
+ lv_expression_2_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getReturnStmtRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:464:3: (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )?
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0==RULE_POST_IF) ) {
+ alt7=1;
+ }
+ switch (alt7) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:464:4: this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) )
+ {
+ this_POST_IF_3=(Token)match(input,RULE_POST_IF,FOLLOW_RULE_POST_IF_in_ruleReturnStmt1062); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_POST_IF_3, grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:468:1: ( (lv_condition_4_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:469:1: (lv_condition_4_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:469:1: (lv_condition_4_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:470:3: lv_condition_4_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleReturnStmt1082);
+ lv_condition_4_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getReturnStmtRule());
+ }
+ set(
+ current,
+ "condition",
+ lv_condition_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleReturnStmt"
+
+
+ // $ANTLR start "entryRuleThrowStmt"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:494:1: entryRuleThrowStmt returns [EObject current=null] : iv_ruleThrowStmt= ruleThrowStmt EOF ;
+ public final EObject entryRuleThrowStmt() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleThrowStmt = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:495:2: (iv_ruleThrowStmt= ruleThrowStmt EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:496:2: iv_ruleThrowStmt= ruleThrowStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getThrowStmtRule());
+ }
+ pushFollow(FOLLOW_ruleThrowStmt_in_entryRuleThrowStmt1120);
+ iv_ruleThrowStmt=ruleThrowStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleThrowStmt;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleThrowStmt1130); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleThrowStmt"
+
+
+ // $ANTLR start "ruleThrowStmt"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:503:1: ruleThrowStmt returns [EObject current=null] : (this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) ) ) ;
+ public final EObject ruleThrowStmt() throws RecognitionException {
+ EObject current = null;
+
+ Token this_THROW_0=null;
+ EObject lv_exp_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:506:28: ( (this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:507:1: (this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:507:1: (this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:507:2: this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) )
+ {
+ this_THROW_0=(Token)match(input,RULE_THROW,FOLLOW_RULE_THROW_in_ruleThrowStmt1166); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_THROW_0, grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:511:1: ( (lv_exp_1_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:512:1: (lv_exp_1_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:512:1: (lv_exp_1_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:513:3: lv_exp_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleThrowStmt1186);
+ lv_exp_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getThrowStmtRule());
+ }
+ set(
+ current,
+ "exp",
+ lv_exp_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleThrowStmt"
+
+
+ // $ANTLR start "entryRuleSuperClass"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:537:1: entryRuleSuperClass returns [EObject current=null] : iv_ruleSuperClass= ruleSuperClass EOF ;
+ public final EObject entryRuleSuperClass() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleSuperClass = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:538:2: (iv_ruleSuperClass= ruleSuperClass EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:539:2: iv_ruleSuperClass= ruleSuperClass EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getSuperClassRule());
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_entryRuleSuperClass1222);
+ iv_ruleSuperClass=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleSuperClass;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleSuperClass1232); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleSuperClass"
+
+
+ // $ANTLR start "ruleSuperClass"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:546:1: ruleSuperClass returns [EObject current=null] : (this_IdRef_0= ruleIdRef | this_Property_1= ruleProperty ) ;
+ public final EObject ruleSuperClass() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_IdRef_0 = null;
+
+ EObject this_Property_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:549:28: ( (this_IdRef_0= ruleIdRef | this_Property_1= ruleProperty ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:550:1: (this_IdRef_0= ruleIdRef | this_Property_1= ruleProperty )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:550:1: (this_IdRef_0= ruleIdRef | this_Property_1= ruleProperty )
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0==RULE_IDENTIFIER) ) {
+ int LA8_1 = input.LA(2);
+
+ if ( ((LA8_1>=RULE_DOT && LA8_1<=RULE_INDEX_START)) ) {
+ alt8=2;
+ }
+ else if ( (LA8_1==EOF||LA8_1==RULE_TERMINATOR||(LA8_1>=RULE_INDENT && LA8_1<=RULE_OUTDENT)||LA8_1==RULE_RPAREN) ) {
+ alt8=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 0, input);
+
+ throw nvae;
+ }
+ switch (alt8) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:551:5: this_IdRef_0= ruleIdRef
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_ruleSuperClass1279);
+ this_IdRef_0=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IdRef_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:561:5: this_Property_1= ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleProperty_in_ruleSuperClass1306);
+ this_Property_1=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Property_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleSuperClass"
+
+
+ // $ANTLR start "entryRuleClassDeclaration"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:577:1: entryRuleClassDeclaration returns [EObject current=null] : iv_ruleClassDeclaration= ruleClassDeclaration EOF ;
+ public final EObject entryRuleClassDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleClassDeclaration = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:578:2: (iv_ruleClassDeclaration= ruleClassDeclaration EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:579:2: iv_ruleClassDeclaration= ruleClassDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getClassDeclarationRule());
+ }
+ pushFollow(FOLLOW_ruleClassDeclaration_in_entryRuleClassDeclaration1341);
+ iv_ruleClassDeclaration=ruleClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleClassDeclaration;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleClassDeclaration1351); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleClassDeclaration"
+
+
+ // $ANTLR start "ruleClassDeclaration"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:586:1: ruleClassDeclaration returns [EObject current=null] : ( () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )? ) ;
+ public final EObject ruleClassDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ Token this_CLASS_1=null;
+ Token this_EXTENDS_3=null;
+ Token this_EXTENDS_7=null;
+ EObject lv_body_2_0 = null;
+
+ EObject lv_extend_4_0 = null;
+
+ EObject lv_body_5_0 = null;
+
+ EObject lv_name_6_1 = null;
+
+ EObject lv_name_6_2 = null;
+
+ EObject lv_extend_8_0 = null;
+
+ EObject lv_body_9_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:589:28: ( ( () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:590:1: ( () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:590:1: ( () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:590:2: () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:590:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:591:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_CLASS_1=(Token)match(input,RULE_CLASS,FOLLOW_RULE_CLASS_in_ruleClassDeclaration1396); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CLASS_1, grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:600:1: ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )?
+ int alt12=4;
+ switch ( input.LA(1) ) {
+ case RULE_INDENT:
+ {
+ alt12=1;
+ }
+ break;
+ case RULE_EXTENDS:
+ {
+ alt12=2;
+ }
+ break;
+ case RULE_IDENTIFIER:
+ {
+ alt12=3;
+ }
+ break;
+ }
+
+ switch (alt12) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:600:2: ( (lv_body_2_0= ruleBlock ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:600:2: ( (lv_body_2_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:601:1: (lv_body_2_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:601:1: (lv_body_2_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:602:3: lv_body_2_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleClassDeclaration1417);
+ lv_body_2_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:619:6: (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:619:6: (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:619:7: this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )?
+ {
+ this_EXTENDS_3=(Token)match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_ruleClassDeclaration1435); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EXTENDS_3, grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:623:1: ( (lv_extend_4_0= ruleSuperClass ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:624:1: (lv_extend_4_0= ruleSuperClass )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:624:1: (lv_extend_4_0= ruleSuperClass )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:625:3: lv_extend_4_0= ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_ruleClassDeclaration1455);
+ lv_extend_4_0=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "extend",
+ lv_extend_4_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:641:2: ( (lv_body_5_0= ruleBlock ) )?
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0==RULE_INDENT) ) {
+ alt9=1;
+ }
+ switch (alt9) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:642:1: (lv_body_5_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:642:1: (lv_body_5_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:643:3: lv_body_5_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleClassDeclaration1476);
+ lv_body_5_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_5_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:660:6: ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:660:6: ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:660:7: ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:660:7: ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:661:1: ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:661:1: ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:662:1: (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:662:1: (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty )
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0==RULE_IDENTIFIER) ) {
+ int LA10_1 = input.LA(2);
+
+ if ( ((LA10_1>=RULE_DOT && LA10_1<=RULE_INDEX_START)) ) {
+ alt10=2;
+ }
+ else if ( (LA10_1==RULE_EXTENDS||LA10_1==RULE_INDENT) ) {
+ alt10=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 10, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 10, 0, input);
+
+ throw nvae;
+ }
+ switch (alt10) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:663:3: lv_name_6_1= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleClassDeclaration1508);
+ lv_name_6_1=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_6_1,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:678:8: lv_name_6_2= ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1());
+
+ }
+ pushFollow(FOLLOW_ruleProperty_in_ruleClassDeclaration1527);
+ lv_name_6_2=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_6_2,
+ "Property");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:696:2: (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )?
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0==RULE_EXTENDS) ) {
+ alt11=1;
+ }
+ switch (alt11) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:696:3: this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) )
+ {
+ this_EXTENDS_7=(Token)match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_ruleClassDeclaration1542); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EXTENDS_7, grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:700:1: ( (lv_extend_8_0= ruleSuperClass ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:701:1: (lv_extend_8_0= ruleSuperClass )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:701:1: (lv_extend_8_0= ruleSuperClass )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:702:3: lv_extend_8_0= ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_ruleClassDeclaration1562);
+ lv_extend_8_0=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "extend",
+ lv_extend_8_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:718:4: ( (lv_body_9_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:719:1: (lv_body_9_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:719:1: (lv_body_9_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:720:3: lv_body_9_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleClassDeclaration1585);
+ lv_body_9_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_9_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleClassDeclaration"
+
+
+ // $ANTLR start "entryRuleAssignedClassDeclaration"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:744:1: entryRuleAssignedClassDeclaration returns [EObject current=null] : iv_ruleAssignedClassDeclaration= ruleAssignedClassDeclaration EOF ;
+ public final EObject entryRuleAssignedClassDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignedClassDeclaration = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:745:2: (iv_ruleAssignedClassDeclaration= ruleAssignedClassDeclaration EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:746:2: iv_ruleAssignedClassDeclaration= ruleAssignedClassDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ pushFollow(FOLLOW_ruleAssignedClassDeclaration_in_entryRuleAssignedClassDeclaration1624);
+ iv_ruleAssignedClassDeclaration=ruleAssignedClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignedClassDeclaration;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignedClassDeclaration1634); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignedClassDeclaration"
+
+
+ // $ANTLR start "ruleAssignedClassDeclaration"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:753:1: ruleAssignedClassDeclaration returns [EObject current=null] : ( () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )? ) ;
+ public final EObject ruleAssignedClassDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ Token this_CLASS_1=null;
+ Token this_EXTENDS_2=null;
+ Token this_EXTENDS_6=null;
+ EObject lv_extend_3_0 = null;
+
+ EObject lv_body_4_0 = null;
+
+ EObject lv_name_5_1 = null;
+
+ EObject lv_name_5_2 = null;
+
+ EObject lv_extend_7_0 = null;
+
+ EObject lv_body_8_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:756:28: ( ( () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:757:1: ( () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:757:1: ( () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:757:2: () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:757:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:758:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_CLASS_1=(Token)match(input,RULE_CLASS,FOLLOW_RULE_CLASS_in_ruleAssignedClassDeclaration1679); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CLASS_1, grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:767:1: ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )?
+ int alt15=3;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0==RULE_EXTENDS) ) {
+ alt15=1;
+ }
+ else if ( (LA15_0==RULE_IDENTIFIER) ) {
+ alt15=2;
+ }
+ switch (alt15) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:767:2: (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:767:2: (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:767:3: this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) )
+ {
+ this_EXTENDS_2=(Token)match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_ruleAssignedClassDeclaration1691); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EXTENDS_2, grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:771:1: ( (lv_extend_3_0= ruleSuperClass ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:772:1: (lv_extend_3_0= ruleSuperClass )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:772:1: (lv_extend_3_0= ruleSuperClass )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:773:3: lv_extend_3_0= ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_ruleAssignedClassDeclaration1711);
+ lv_extend_3_0=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "extend",
+ lv_extend_3_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:789:2: ( (lv_body_4_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:790:1: (lv_body_4_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:790:1: (lv_body_4_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:791:3: lv_body_4_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleAssignedClassDeclaration1732);
+ lv_body_4_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:808:6: ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:808:6: ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:808:7: ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:808:7: ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:809:1: ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:809:1: ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:810:1: (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:810:1: (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty )
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( (LA13_0==RULE_IDENTIFIER) ) {
+ int LA13_1 = input.LA(2);
+
+ if ( ((LA13_1>=RULE_DOT && LA13_1<=RULE_INDEX_START)) ) {
+ alt13=2;
+ }
+ else if ( (LA13_1==RULE_EXTENDS||LA13_1==RULE_INDENT) ) {
+ alt13=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 13, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 13, 0, input);
+
+ throw nvae;
+ }
+ switch (alt13) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:811:3: lv_name_5_1= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleAssignedClassDeclaration1763);
+ lv_name_5_1=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_5_1,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:826:8: lv_name_5_2= ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1());
+
+ }
+ pushFollow(FOLLOW_ruleProperty_in_ruleAssignedClassDeclaration1782);
+ lv_name_5_2=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_5_2,
+ "Property");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:844:2: (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )?
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0==RULE_EXTENDS) ) {
+ alt14=1;
+ }
+ switch (alt14) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:844:3: this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) )
+ {
+ this_EXTENDS_6=(Token)match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_ruleAssignedClassDeclaration1797); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EXTENDS_6, grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:848:1: ( (lv_extend_7_0= ruleSuperClass ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:849:1: (lv_extend_7_0= ruleSuperClass )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:849:1: (lv_extend_7_0= ruleSuperClass )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:850:3: lv_extend_7_0= ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_ruleAssignedClassDeclaration1817);
+ lv_extend_7_0=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "extend",
+ lv_extend_7_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:866:4: ( (lv_body_8_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:867:1: (lv_body_8_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:867:1: (lv_body_8_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:868:3: lv_body_8_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleAssignedClassDeclaration1840);
+ lv_body_8_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_8_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignedClassDeclaration"
+
+
+ // $ANTLR start "entryRuleExpression"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:892:1: entryRuleExpression returns [EObject current=null] : iv_ruleExpression= ruleExpression EOF ;
+ public final EObject entryRuleExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleExpression = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:893:2: (iv_ruleExpression= ruleExpression EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:894:2: iv_ruleExpression= ruleExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getExpressionRule());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_entryRuleExpression1879);
+ iv_ruleExpression=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleExpression;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExpression1889); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleExpression"
+
+
+ // $ANTLR start "ruleExpression"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:901:1: ruleExpression returns [EObject current=null] : this_Postfix_0= rulePostfix ;
+ public final EObject ruleExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Postfix_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:904:28: (this_Postfix_0= rulePostfix )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:906:5: this_Postfix_0= rulePostfix
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExpressionAccess().getPostfixParserRuleCall());
+
+ }
+ pushFollow(FOLLOW_rulePostfix_in_ruleExpression1935);
+ this_Postfix_0=rulePostfix();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Postfix_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleExpression"
+
+
+ // $ANTLR start "entryRulePostfix"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:922:1: entryRulePostfix returns [EObject current=null] : iv_rulePostfix= rulePostfix EOF ;
+ public final EObject entryRulePostfix() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_rulePostfix = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:923:2: (iv_rulePostfix= rulePostfix EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:924:2: iv_rulePostfix= rulePostfix EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getPostfixRule());
+ }
+ pushFollow(FOLLOW_rulePostfix_in_entryRulePostfix1969);
+ iv_rulePostfix=rulePostfix();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_rulePostfix;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRulePostfix1979); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRulePostfix"
+
+
+ // $ANTLR start "rulePostfix"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:931:1: rulePostfix returns [EObject current=null] : (this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )? ) ;
+ public final EObject rulePostfix() throws RecognitionException {
+ EObject current = null;
+
+ Token this_POST_IF_1=null;
+ Token this_FOR_4=null;
+ Token this_WHILE_7=null;
+ Token this_WHEN_10=null;
+ Token this_UNTIL_12=null;
+ Token this_WHEN_15=null;
+ EObject this_Assignment_0 = null;
+
+ EObject lv_condition_3_0 = null;
+
+ EObject lv_body_6_0 = null;
+
+ EObject lv_body_9_0 = null;
+
+ EObject lv_when_11_0 = null;
+
+ EObject lv_body_14_0 = null;
+
+ EObject lv_when_16_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:934:28: ( (this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:935:1: (this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:935:1: (this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:936:5: this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )?
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignment_in_rulePostfix2026);
+ this_Assignment_0=ruleAssignment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Assignment_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:944:1: ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )?
+ int alt18=5;
+ alt18 = dfa18.predict(input);
+ switch (alt18) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:944:2: ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:944:2: ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:944:3: ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:944:3: ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:944:4: ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF
+ {
+ this_POST_IF_1=(Token)match(input,RULE_POST_IF,FOLLOW_RULE_POST_IF_in_rulePostfix2044); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_POST_IF_1, grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:948:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:949:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:954:2: ( (lv_condition_3_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:955:1: (lv_condition_3_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:955:1: (lv_condition_3_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:956:3: lv_condition_3_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2074);
+ lv_condition_3_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "condition",
+ lv_condition_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:973:6: ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:973:6: ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:973:7: ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:973:7: ( ( RULE_FOR )=>this_FOR_4= RULE_FOR )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:973:8: ( RULE_FOR )=>this_FOR_4= RULE_FOR
+ {
+ this_FOR_4=(Token)match(input,RULE_FOR,FOLLOW_RULE_FOR_in_rulePostfix2099); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FOR_4, grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:977:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:978:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getForDummyAction_1_1_1(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:983:2: ( (lv_body_6_0= ruleForBody ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:984:1: (lv_body_6_0= ruleForBody )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:984:1: (lv_body_6_0= ruleForBody )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:985:3: lv_body_6_0= ruleForBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleForBody_in_rulePostfix2129);
+ lv_body_6_0=ruleForBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_6_0,
+ "ForBody");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1002:6: ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1002:6: ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1002:7: ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1002:7: ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1002:8: ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE
+ {
+ this_WHILE_7=(Token)match(input,RULE_WHILE,FOLLOW_RULE_WHILE_in_rulePostfix2154); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHILE_7, grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1006:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1007:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1012:2: ( (lv_body_9_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1013:1: (lv_body_9_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1013:1: (lv_body_9_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1014:3: lv_body_9_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2184);
+ lv_body_9_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_9_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1030:2: ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )?
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0==RULE_WHEN) ) {
+ int LA16_1 = input.LA(2);
+
+ if ( (synpred6_InternalCoffeeScript()) ) {
+ alt16=1;
+ }
+ }
+ switch (alt16) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1030:3: ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1030:3: ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1030:4: ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN
+ {
+ this_WHEN_10=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rulePostfix2202); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_10, grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1034:2: ( (lv_when_11_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1035:1: (lv_when_11_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1035:1: (lv_when_11_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1036:3: lv_when_11_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2223);
+ lv_when_11_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_11_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1053:6: ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1053:6: ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1053:7: ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1053:7: ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1053:8: ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL
+ {
+ this_UNTIL_12=(Token)match(input,RULE_UNTIL,FOLLOW_RULE_UNTIL_in_rulePostfix2250); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_UNTIL_12, grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1057:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1058:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1063:2: ( (lv_body_14_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1064:1: (lv_body_14_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1064:1: (lv_body_14_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1065:3: lv_body_14_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2280);
+ lv_body_14_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_14_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1081:2: ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )?
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( (LA17_0==RULE_WHEN) ) {
+ int LA17_1 = input.LA(2);
+
+ if ( (synpred8_InternalCoffeeScript()) ) {
+ alt17=1;
+ }
+ }
+ switch (alt17) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1081:3: ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1081:3: ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1081:4: ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN
+ {
+ this_WHEN_15=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rulePostfix2298); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_15, grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1085:2: ( (lv_when_16_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1086:1: (lv_when_16_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1086:1: (lv_when_16_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1087:3: lv_when_16_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2319);
+ lv_when_16_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_16_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "rulePostfix"
+
+
+ // $ANTLR start "entryRuleForBody"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1111:1: entryRuleForBody returns [EObject current=null] : iv_ruleForBody= ruleForBody EOF ;
+ public final EObject entryRuleForBody() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleForBody = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1112:2: (iv_ruleForBody= ruleForBody EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1113:2: iv_ruleForBody= ruleForBody EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getForBodyRule());
+ }
+ pushFollow(FOLLOW_ruleForBody_in_entryRuleForBody2360);
+ iv_ruleForBody=ruleForBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleForBody;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleForBody2370); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleForBody"
+
+
+ // $ANTLR start "ruleForBody"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1120:1: ruleForBody returns [EObject current=null] : ( (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) ) ) ;
+ public final EObject ruleForBody() throws RecognitionException {
+ EObject current = null;
+
+ Token this_OWN_0=null;
+ Token this_COMMA_2=null;
+ EObject lv_indexes_1_0 = null;
+
+ EObject lv_indexes_3_0 = null;
+
+ EObject lv_source_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1123:28: ( ( (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1124:1: ( (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1124:1: ( (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1124:2: (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1124:2: (this_OWN_0= RULE_OWN )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0==RULE_OWN) ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1124:3: this_OWN_0= RULE_OWN
+ {
+ this_OWN_0=(Token)match(input,RULE_OWN,FOLLOW_RULE_OWN_in_ruleForBody2407); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OWN_0, grammarAccess.getForBodyAccess().getOWNTerminalRuleCall_0());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1128:3: ( (lv_indexes_1_0= ruleForValue ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1129:1: (lv_indexes_1_0= ruleForValue )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1129:1: (lv_indexes_1_0= ruleForValue )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1130:3: lv_indexes_1_0= ruleForValue
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleForValue_in_ruleForBody2429);
+ lv_indexes_1_0=ruleForValue();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ add(
+ current,
+ "indexes",
+ lv_indexes_1_0,
+ "ForValue");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1146:2: (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )*
+ loop20:
+ do {
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0==RULE_COMMA) ) {
+ alt20=1;
+ }
+
+
+ switch (alt20) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1146:3: this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) )
+ {
+ this_COMMA_2=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleForBody2441); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_2, grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1150:1: ( (lv_indexes_3_0= ruleForValue ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1151:1: (lv_indexes_3_0= ruleForValue )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1151:1: (lv_indexes_3_0= ruleForValue )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1152:3: lv_indexes_3_0= ruleForValue
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleForValue_in_ruleForBody2461);
+ lv_indexes_3_0=ruleForValue();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ add(
+ current,
+ "indexes",
+ lv_indexes_3_0,
+ "ForValue");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop20;
+ }
+ } while (true);
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1168:4: ( (lv_source_4_0= ruleForSource ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1169:1: (lv_source_4_0= ruleForSource )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1169:1: (lv_source_4_0= ruleForSource )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1170:3: lv_source_4_0= ruleForSource
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleForSource_in_ruleForBody2484);
+ lv_source_4_0=ruleForSource();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ set(
+ current,
+ "source",
+ lv_source_4_0,
+ "ForSource");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleForBody"
+
+
+ // $ANTLR start "entryRuleForValue"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1194:1: entryRuleForValue returns [EObject current=null] : iv_ruleForValue= ruleForValue EOF ;
+ public final EObject entryRuleForValue() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleForValue = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1195:2: (iv_ruleForValue= ruleForValue EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1196:2: iv_ruleForValue= ruleForValue EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getForValueRule());
+ }
+ pushFollow(FOLLOW_ruleForValue_in_entryRuleForValue2520);
+ iv_ruleForValue=ruleForValue();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleForValue;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleForValue2530); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleForValue"
+
+
+ // $ANTLR start "ruleForValue"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1203:1: ruleForValue returns [EObject current=null] : this_Id_0= ruleId ;
+ public final EObject ruleForValue() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Id_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1206:28: (this_Id_0= ruleId )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1208:5: this_Id_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForValueAccess().getIdParserRuleCall());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleForValue2576);
+ this_Id_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleForValue"
+
+
+ // $ANTLR start "entryRuleForSource"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1224:1: entryRuleForSource returns [EObject current=null] : iv_ruleForSource= ruleForSource EOF ;
+ public final EObject entryRuleForSource() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleForSource = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1225:2: (iv_ruleForSource= ruleForSource EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1226:2: iv_ruleForSource= ruleForSource EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getForSourceRule());
+ }
+ pushFollow(FOLLOW_ruleForSource_in_entryRuleForSource2610);
+ iv_ruleForSource=ruleForSource();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleForSource;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleForSource2620); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleForSource"
+
+
+ // $ANTLR start "ruleForSource"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1233:1: ruleForSource returns [EObject current=null] : ( () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) ) ) ;
+ public final EObject ruleForSource() throws RecognitionException {
+ EObject current = null;
+
+ Token this_FOROF_1=null;
+ Token this_WHEN_3=null;
+ Token this_FORIN_5=null;
+ Token this_WHEN_7=null;
+ Token this_BY_9=null;
+ Token this_BY_11=null;
+ Token this_WHEN_13=null;
+ EObject lv_source_2_0 = null;
+
+ EObject lv_when_4_0 = null;
+
+ EObject lv_source_6_0 = null;
+
+ EObject lv_when_8_0 = null;
+
+ EObject lv_by_10_0 = null;
+
+ EObject lv_by_12_0 = null;
+
+ EObject lv_when_14_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1236:28: ( ( () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1237:1: ( () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1237:1: ( () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1237:2: () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1237:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1238:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getForSourceAccess().getForSourceAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1243:2: ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) )
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( (LA25_0==RULE_FOROF) && (synpred9_InternalCoffeeScript())) {
+ alt25=1;
+ }
+ else if ( (LA25_0==RULE_FORIN) && (synpred11_InternalCoffeeScript())) {
+ alt25=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 25, 0, input);
+
+ throw nvae;
+ }
+ switch (alt25) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1243:3: ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1243:3: ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1243:4: ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1243:4: ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1243:5: ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF
+ {
+ this_FOROF_1=(Token)match(input,RULE_FOROF,FOLLOW_RULE_FOROF_in_ruleForSource2673); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FOROF_1, grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1247:2: ( (lv_source_2_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1248:1: (lv_source_2_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1248:1: (lv_source_2_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1249:3: lv_source_2_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2694);
+ lv_source_2_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "source",
+ lv_source_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1265:2: ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )?
+ int alt21=2;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0==RULE_WHEN) ) {
+ int LA21_1 = input.LA(2);
+
+ if ( (synpred10_InternalCoffeeScript()) ) {
+ alt21=1;
+ }
+ }
+ switch (alt21) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1265:3: ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1265:3: ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1265:4: ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN
+ {
+ this_WHEN_3=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_ruleForSource2712); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_3, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1269:2: ( (lv_when_4_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1270:1: (lv_when_4_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1270:1: (lv_when_4_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1271:3: lv_when_4_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2733);
+ lv_when_4_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1288:6: ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1288:6: ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1288:7: ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1288:7: ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1288:8: ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN
+ {
+ this_FORIN_5=(Token)match(input,RULE_FORIN,FOLLOW_RULE_FORIN_in_ruleForSource2760); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FORIN_5, grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1292:2: ( (lv_source_6_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1293:1: (lv_source_6_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1293:1: (lv_source_6_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1294:3: lv_source_6_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2781);
+ lv_source_6_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "source",
+ lv_source_6_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1310:2: ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )?
+ int alt24=3;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0==RULE_WHEN) ) {
+ int LA24_1 = input.LA(2);
+
+ if ( (synpred12_InternalCoffeeScript()) ) {
+ alt24=1;
+ }
+ }
+ else if ( (LA24_0==RULE_BY) ) {
+ int LA24_2 = input.LA(2);
+
+ if ( (synpred14_InternalCoffeeScript()) ) {
+ alt24=2;
+ }
+ }
+ switch (alt24) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1310:3: ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1310:3: ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1310:4: ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1310:4: ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1310:5: ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN
+ {
+ this_WHEN_7=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_ruleForSource2800); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_7, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1314:2: ( (lv_when_8_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1315:1: (lv_when_8_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1315:1: (lv_when_8_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1316:3: lv_when_8_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2821);
+ lv_when_8_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_8_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1332:2: ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )?
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( (LA22_0==RULE_BY) ) {
+ int LA22_1 = input.LA(2);
+
+ if ( (synpred13_InternalCoffeeScript()) ) {
+ alt22=1;
+ }
+ }
+ switch (alt22) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1332:3: ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1332:3: ( ( RULE_BY )=>this_BY_9= RULE_BY )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1332:4: ( RULE_BY )=>this_BY_9= RULE_BY
+ {
+ this_BY_9=(Token)match(input,RULE_BY,FOLLOW_RULE_BY_in_ruleForSource2839); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_BY_9, grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1336:2: ( (lv_by_10_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1337:1: (lv_by_10_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1337:1: (lv_by_10_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1338:3: lv_by_10_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2860);
+ lv_by_10_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "by",
+ lv_by_10_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1355:6: ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1355:6: ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1355:7: ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1355:7: ( ( RULE_BY )=>this_BY_11= RULE_BY )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1355:8: ( RULE_BY )=>this_BY_11= RULE_BY
+ {
+ this_BY_11=(Token)match(input,RULE_BY,FOLLOW_RULE_BY_in_ruleForSource2887); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_BY_11, grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1359:2: ( (lv_by_12_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1360:1: (lv_by_12_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1360:1: (lv_by_12_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1361:3: lv_by_12_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2908);
+ lv_by_12_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "by",
+ lv_by_12_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1377:2: ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )?
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( (LA23_0==RULE_WHEN) ) {
+ int LA23_1 = input.LA(2);
+
+ if ( (synpred15_InternalCoffeeScript()) ) {
+ alt23=1;
+ }
+ }
+ switch (alt23) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1377:3: ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1377:3: ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1377:4: ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN
+ {
+ this_WHEN_13=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_ruleForSource2926); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_13, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1381:2: ( (lv_when_14_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1382:1: (lv_when_14_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1382:1: (lv_when_14_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1383:3: lv_when_14_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2947);
+ lv_when_14_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_14_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleForSource"
+
+
+ // $ANTLR start "entryRuleRange"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1407:1: entryRuleRange returns [EObject current=null] : iv_ruleRange= ruleRange EOF ;
+ public final EObject entryRuleRange() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRange = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1408:2: (iv_ruleRange= ruleRange EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1409:2: iv_ruleRange= ruleRange EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getRangeRule());
+ }
+ pushFollow(FOLLOW_ruleRange_in_entryRuleRange2990);
+ iv_ruleRange=ruleRange();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleRange;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRange3000); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRange"
+
+
+ // $ANTLR start "ruleRange"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1416:1: ruleRange returns [EObject current=null] : ( ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET ) ;
+ public final EObject ruleRange() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LBRACKET_0=null;
+ Token this_DOT_DOT_2=null;
+ Token this_ELLIPSIS_3=null;
+ Token this_RBRACKET_5=null;
+ EObject lv_start_1_0 = null;
+
+ EObject lv_end_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1419:28: ( ( ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1420:1: ( ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1420:1: ( ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1420:2: ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1420:2: ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1420:3: ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1425:25: (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1425:26: this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS )
+ {
+ this_LBRACKET_0=(Token)match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_ruleRange3066); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LBRACKET_0, grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1429:1: ( (lv_start_1_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1430:1: (lv_start_1_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1430:1: (lv_start_1_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1431:3: lv_start_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleRange3086);
+ lv_start_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRangeRule());
+ }
+ set(
+ current,
+ "start",
+ lv_start_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1447:2: (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS )
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0==RULE_DOT_DOT) ) {
+ alt26=1;
+ }
+ else if ( (LA26_0==RULE_ELLIPSIS) ) {
+ alt26=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 26, 0, input);
+
+ throw nvae;
+ }
+ switch (alt26) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1447:3: this_DOT_DOT_2= RULE_DOT_DOT
+ {
+ this_DOT_DOT_2=(Token)match(input,RULE_DOT_DOT,FOLLOW_RULE_DOT_DOT_in_ruleRange3098); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_DOT_DOT_2, grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1452:6: this_ELLIPSIS_3= RULE_ELLIPSIS
+ {
+ this_ELLIPSIS_3=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleRange3114); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_ELLIPSIS_3, grammarAccess.getRangeAccess().getELLIPSISTerminalRuleCall_0_0_2_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1456:4: ( (lv_end_4_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1457:1: (lv_end_4_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1457:1: (lv_end_4_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1458:3: lv_end_4_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleRange3137);
+ lv_end_4_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRangeRule());
+ }
+ set(
+ current,
+ "end",
+ lv_end_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_RBRACKET_5=(Token)match(input,RULE_RBRACKET,FOLLOW_RULE_RBRACKET_in_ruleRange3148); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RBRACKET_5, grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRange"
+
+
+ // $ANTLR start "entryRuleAssignment"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1486:1: entryRuleAssignment returns [EObject current=null] : iv_ruleAssignment= ruleAssignment EOF ;
+ public final EObject entryRuleAssignment() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignment = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1487:2: (iv_ruleAssignment= ruleAssignment EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1488:2: iv_ruleAssignment= ruleAssignment EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignmentRule());
+ }
+ pushFollow(FOLLOW_ruleAssignment_in_entryRuleAssignment3183);
+ iv_ruleAssignment=ruleAssignment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignment;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignment3193); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignment"
+
+
+ // $ANTLR start "ruleAssignment"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1495:1: ruleAssignment returns [EObject current=null] : ( ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp ) ;
+ public final EObject ruleAssignment() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_1_1=null;
+ Token lv_operator_1_2=null;
+ EObject lv_left_0_0 = null;
+
+ EObject lv_right_2_0 = null;
+
+ EObject this_LogicOp_3 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1498:28: ( ( ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:1: ( ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:1: ( ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp )
+ int alt28=2;
+ alt28 = dfa28.predict(input);
+ switch (alt28) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:2: ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:2: ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:3: ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:3: ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:4: ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1513:6: ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1513:7: ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1513:7: ( (lv_left_0_0= ruleAssignable ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1514:1: (lv_left_0_0= ruleAssignable )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1514:1: (lv_left_0_0= ruleAssignable )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1515:3: lv_left_0_0= ruleAssignable
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignable_in_ruleAssignment3281);
+ lv_left_0_0=ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignmentRule());
+ }
+ set(
+ current,
+ "left",
+ lv_left_0_0,
+ "Assignable");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1531:2: ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1532:1: ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1532:1: ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1533:1: (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1533:1: (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN )
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( (LA27_0==RULE_EQUAL) ) {
+ alt27=1;
+ }
+ else if ( (LA27_0==RULE_COMPOUND_ASSIGN) ) {
+ alt27=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 27, 0, input);
+
+ throw nvae;
+ }
+ switch (alt27) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1534:3: lv_operator_1_1= RULE_EQUAL
+ {
+ lv_operator_1_1=(Token)match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_ruleAssignment3300); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_1_1, grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAssignmentRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_1_1,
+ "EQUAL");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1549:8: lv_operator_1_2= RULE_COMPOUND_ASSIGN
+ {
+ lv_operator_1_2=(Token)match(input,RULE_COMPOUND_ASSIGN,FOLLOW_RULE_COMPOUND_ASSIGN_in_ruleAssignment3320); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_1_2, grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAssignmentRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_1_2,
+ "COMPOUND_ASSIGN");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1567:4: ( (lv_right_2_0= ruleAssigned ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1568:1: (lv_right_2_0= ruleAssigned )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1568:1: (lv_right_2_0= ruleAssigned )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1569:3: lv_right_2_0= ruleAssigned
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssigned_in_ruleAssignment3351);
+ lv_right_2_0=ruleAssigned();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignmentRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_2_0,
+ "Assigned");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1587:5: this_LogicOp_3= ruleLogicOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleLogicOp_in_ruleAssignment3380);
+ this_LogicOp_3=ruleLogicOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_LogicOp_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignment"
+
+
+ // $ANTLR start "entryRuleAssigned"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1603:1: entryRuleAssigned returns [EObject current=null] : iv_ruleAssigned= ruleAssigned EOF ;
+ public final EObject entryRuleAssigned() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssigned = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1604:2: (iv_ruleAssigned= ruleAssigned EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1605:2: iv_ruleAssigned= ruleAssigned EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignedRule());
+ }
+ pushFollow(FOLLOW_ruleAssigned_in_entryRuleAssigned3415);
+ iv_ruleAssigned=ruleAssigned();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssigned;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssigned3425); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssigned"
+
+
+ // $ANTLR start "ruleAssigned"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1612:1: ruleAssigned returns [EObject current=null] : (this_Expression_0= ruleExpression | (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT ) | this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration ) ;
+ public final EObject ruleAssigned() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDENT_1=null;
+ Token this_OUTDENT_3=null;
+ EObject this_Expression_0 = null;
+
+ EObject this_Expression_2 = null;
+
+ EObject this_AssignedClassDeclaration_4 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1615:28: ( (this_Expression_0= ruleExpression | (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT ) | this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1616:1: (this_Expression_0= ruleExpression | (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT ) | this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1616:1: (this_Expression_0= ruleExpression | (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT ) | this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration )
+ int alt29=3;
+ switch ( input.LA(1) ) {
+ case RULE_STRING:
+ case RULE_FOR:
+ case RULE_WHILE:
+ case RULE_UNTIL:
+ case RULE_LBRACKET:
+ case RULE_PLUS:
+ case RULE_MINUS:
+ case RULE_UNARY:
+ case RULE_PLUS_PLUS:
+ case RULE_MINUS_MINUS:
+ case RULE_SUPER:
+ case RULE_AT_SIGIL:
+ case RULE_THIS:
+ case RULE_LOOP:
+ case RULE_TRY:
+ case RULE_SWITCH:
+ case RULE_IF:
+ case RULE_IDENTIFIER:
+ case RULE_LCURLY:
+ case RULE_PARAM_START:
+ case RULE_FUNC_ARROW:
+ case RULE_BOUND_FUNC_ARROW:
+ case RULE_NUMBER:
+ case RULE_BOOL:
+ case RULE_JS:
+ case RULE_REGEX:
+ case RULE_LPAREN:
+ {
+ alt29=1;
+ }
+ break;
+ case RULE_INDENT:
+ {
+ alt29=2;
+ }
+ break;
+ case RULE_CLASS:
+ {
+ alt29=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 29, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt29) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1617:5: this_Expression_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleAssigned3472);
+ this_Expression_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Expression_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1626:6: (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1626:6: (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1626:7: this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT
+ {
+ this_INDENT_1=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleAssigned3489); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_1, grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleAssigned3510);
+ this_Expression_2=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Expression_2;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_OUTDENT_3=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleAssigned3520); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_3, grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1645:5: this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleAssignedClassDeclaration_in_ruleAssigned3548);
+ this_AssignedClassDeclaration_4=ruleAssignedClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_AssignedClassDeclaration_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssigned"
+
+
+ // $ANTLR start "entryRuleLogicOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1661:1: entryRuleLogicOp returns [EObject current=null] : iv_ruleLogicOp= ruleLogicOp EOF ;
+ public final EObject entryRuleLogicOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleLogicOp = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1662:2: (iv_ruleLogicOp= ruleLogicOp EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1663:2: iv_ruleLogicOp= ruleLogicOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getLogicOpRule());
+ }
+ pushFollow(FOLLOW_ruleLogicOp_in_entryRuleLogicOp3583);
+ iv_ruleLogicOp=ruleLogicOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleLogicOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLogicOp3593); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleLogicOp"
+
+
+ // $ANTLR start "ruleLogicOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1670:1: ruleLogicOp returns [EObject current=null] : (this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )* ) ;
+ public final EObject ruleLogicOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_CompareOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1673:28: ( (this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1674:1: (this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1674:1: (this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1675:5: this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleCompareOp_in_ruleLogicOp3640);
+ this_CompareOp_0=ruleCompareOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_CompareOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1683:1: ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )*
+ loop30:
+ do {
+ int alt30=2;
+ int LA30_0 = input.LA(1);
+
+ if ( (LA30_0==RULE_LOGIC) ) {
+ int LA30_2 = input.LA(2);
+
+ if ( (synpred18_InternalCoffeeScript()) ) {
+ alt30=1;
+ }
+
+
+ }
+
+
+ switch (alt30) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1683:2: ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1683:2: ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1683:3: ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1689:6: ( () ( (lv_operator_2_0= RULE_LOGIC ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1689:7: () ( (lv_operator_2_0= RULE_LOGIC ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1689:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1690:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1695:2: ( (lv_operator_2_0= RULE_LOGIC ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1696:1: (lv_operator_2_0= RULE_LOGIC )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1696:1: (lv_operator_2_0= RULE_LOGIC )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1697:3: lv_operator_2_0= RULE_LOGIC
+ {
+ lv_operator_2_0=(Token)match(input,RULE_LOGIC,FOLLOW_RULE_LOGIC_in_ruleLogicOp3686); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getLogicOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "LOGIC");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1713:4: ( (lv_right_3_0= ruleCompareOp ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1714:1: (lv_right_3_0= ruleCompareOp )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1714:1: (lv_right_3_0= ruleCompareOp )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1715:3: lv_right_3_0= ruleCompareOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleCompareOp_in_ruleLogicOp3714);
+ lv_right_3_0=ruleCompareOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getLogicOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "CompareOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop30;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleLogicOp"
+
+
+ // $ANTLR start "entryRuleCompareOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1739:1: entryRuleCompareOp returns [EObject current=null] : iv_ruleCompareOp= ruleCompareOp EOF ;
+ public final EObject entryRuleCompareOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleCompareOp = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1740:2: (iv_ruleCompareOp= ruleCompareOp EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1741:2: iv_ruleCompareOp= ruleCompareOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getCompareOpRule());
+ }
+ pushFollow(FOLLOW_ruleCompareOp_in_entryRuleCompareOp3752);
+ iv_ruleCompareOp=ruleCompareOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleCompareOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCompareOp3762); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleCompareOp"
+
+
+ // $ANTLR start "ruleCompareOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1748:1: ruleCompareOp returns [EObject current=null] : (this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )* ) ;
+ public final EObject ruleCompareOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_RelationOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1751:28: ( (this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1752:1: (this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1752:1: (this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1753:5: this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleRelationOp_in_ruleCompareOp3809);
+ this_RelationOp_0=ruleRelationOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_RelationOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1761:1: ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )*
+ loop31:
+ do {
+ int alt31=2;
+ int LA31_0 = input.LA(1);
+
+ if ( (LA31_0==RULE_COMPARE) ) {
+ int LA31_2 = input.LA(2);
+
+ if ( (synpred19_InternalCoffeeScript()) ) {
+ alt31=1;
+ }
+
+
+ }
+
+
+ switch (alt31) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1761:2: ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1761:2: ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1761:3: ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1767:6: ( () ( (lv_operator_2_0= RULE_COMPARE ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1767:7: () ( (lv_operator_2_0= RULE_COMPARE ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1767:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1768:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1773:2: ( (lv_operator_2_0= RULE_COMPARE ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1774:1: (lv_operator_2_0= RULE_COMPARE )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1774:1: (lv_operator_2_0= RULE_COMPARE )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1775:3: lv_operator_2_0= RULE_COMPARE
+ {
+ lv_operator_2_0=(Token)match(input,RULE_COMPARE,FOLLOW_RULE_COMPARE_in_ruleCompareOp3855); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getCompareOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "COMPARE");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1791:4: ( (lv_right_3_0= ruleRelationOp ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1792:1: (lv_right_3_0= ruleRelationOp )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1792:1: (lv_right_3_0= ruleRelationOp )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1793:3: lv_right_3_0= ruleRelationOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleRelationOp_in_ruleCompareOp3883);
+ lv_right_3_0=ruleRelationOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCompareOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "RelationOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop31;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleCompareOp"
+
+
+ // $ANTLR start "entryRuleRelationOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1817:1: entryRuleRelationOp returns [EObject current=null] : iv_ruleRelationOp= ruleRelationOp EOF ;
+ public final EObject entryRuleRelationOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRelationOp = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1818:2: (iv_ruleRelationOp= ruleRelationOp EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1819:2: iv_ruleRelationOp= ruleRelationOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getRelationOpRule());
+ }
+ pushFollow(FOLLOW_ruleRelationOp_in_entryRuleRelationOp3921);
+ iv_ruleRelationOp=ruleRelationOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleRelationOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRelationOp3931); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRelationOp"
+
+
+ // $ANTLR start "ruleRelationOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1826:1: ruleRelationOp returns [EObject current=null] : (this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )* ) ;
+ public final EObject ruleRelationOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_ShiftOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1829:28: ( (this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1830:1: (this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1830:1: (this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1831:5: this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleShiftOp_in_ruleRelationOp3978);
+ this_ShiftOp_0=ruleShiftOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ShiftOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1839:1: ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )*
+ loop32:
+ do {
+ int alt32=2;
+ int LA32_0 = input.LA(1);
+
+ if ( (LA32_0==RULE_RELATION) ) {
+ int LA32_2 = input.LA(2);
+
+ if ( (synpred20_InternalCoffeeScript()) ) {
+ alt32=1;
+ }
+
+
+ }
+
+
+ switch (alt32) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1839:2: ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1839:2: ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1839:3: ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1845:6: ( () ( (lv_operator_2_0= RULE_RELATION ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1845:7: () ( (lv_operator_2_0= RULE_RELATION ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1845:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1846:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1851:2: ( (lv_operator_2_0= RULE_RELATION ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1852:1: (lv_operator_2_0= RULE_RELATION )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1852:1: (lv_operator_2_0= RULE_RELATION )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1853:3: lv_operator_2_0= RULE_RELATION
+ {
+ lv_operator_2_0=(Token)match(input,RULE_RELATION,FOLLOW_RULE_RELATION_in_ruleRelationOp4024); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRelationOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "RELATION");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1869:4: ( (lv_right_3_0= ruleShiftOp ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1870:1: (lv_right_3_0= ruleShiftOp )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1870:1: (lv_right_3_0= ruleShiftOp )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1871:3: lv_right_3_0= ruleShiftOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleShiftOp_in_ruleRelationOp4052);
+ lv_right_3_0=ruleShiftOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRelationOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "ShiftOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop32;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRelationOp"
+
+
+ // $ANTLR start "entryRuleShiftOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1895:1: entryRuleShiftOp returns [EObject current=null] : iv_ruleShiftOp= ruleShiftOp EOF ;
+ public final EObject entryRuleShiftOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleShiftOp = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1896:2: (iv_ruleShiftOp= ruleShiftOp EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1897:2: iv_ruleShiftOp= ruleShiftOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getShiftOpRule());
+ }
+ pushFollow(FOLLOW_ruleShiftOp_in_entryRuleShiftOp4090);
+ iv_ruleShiftOp=ruleShiftOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleShiftOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleShiftOp4100); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleShiftOp"
+
+
+ // $ANTLR start "ruleShiftOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1904:1: ruleShiftOp returns [EObject current=null] : (this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )* ) ;
+ public final EObject ruleShiftOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_AdditiveOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1907:28: ( (this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1908:1: (this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1908:1: (this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1909:5: this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleAdditiveOp_in_ruleShiftOp4147);
+ this_AdditiveOp_0=ruleAdditiveOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_AdditiveOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1917:1: ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )*
+ loop33:
+ do {
+ int alt33=2;
+ int LA33_0 = input.LA(1);
+
+ if ( (LA33_0==RULE_SHIFT) ) {
+ int LA33_2 = input.LA(2);
+
+ if ( (synpred21_InternalCoffeeScript()) ) {
+ alt33=1;
+ }
+
+
+ }
+
+
+ switch (alt33) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1917:2: ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1917:2: ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1917:3: ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1923:6: ( () ( (lv_operator_2_0= RULE_SHIFT ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1923:7: () ( (lv_operator_2_0= RULE_SHIFT ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1923:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1924:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1929:2: ( (lv_operator_2_0= RULE_SHIFT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1930:1: (lv_operator_2_0= RULE_SHIFT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1930:1: (lv_operator_2_0= RULE_SHIFT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1931:3: lv_operator_2_0= RULE_SHIFT
+ {
+ lv_operator_2_0=(Token)match(input,RULE_SHIFT,FOLLOW_RULE_SHIFT_in_ruleShiftOp4193); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getShiftOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "SHIFT");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1947:4: ( (lv_right_3_0= ruleAdditiveOp ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1948:1: (lv_right_3_0= ruleAdditiveOp )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1948:1: (lv_right_3_0= ruleAdditiveOp )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1949:3: lv_right_3_0= ruleAdditiveOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleAdditiveOp_in_ruleShiftOp4221);
+ lv_right_3_0=ruleAdditiveOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getShiftOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "AdditiveOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop33;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleShiftOp"
+
+
+ // $ANTLR start "entryRuleAdditiveOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1973:1: entryRuleAdditiveOp returns [EObject current=null] : iv_ruleAdditiveOp= ruleAdditiveOp EOF ;
+ public final EObject entryRuleAdditiveOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAdditiveOp = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1974:2: (iv_ruleAdditiveOp= ruleAdditiveOp EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1975:2: iv_ruleAdditiveOp= ruleAdditiveOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAdditiveOpRule());
+ }
+ pushFollow(FOLLOW_ruleAdditiveOp_in_entryRuleAdditiveOp4259);
+ iv_ruleAdditiveOp=ruleAdditiveOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAdditiveOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAdditiveOp4269); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAdditiveOp"
+
+
+ // $ANTLR start "ruleAdditiveOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1982:1: ruleAdditiveOp returns [EObject current=null] : (this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )* ) ;
+ public final EObject ruleAdditiveOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_1=null;
+ Token lv_operator_2_2=null;
+ EObject this_MathOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1985:28: ( (this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1986:1: (this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1986:1: (this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1987:5: this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleMathOp_in_ruleAdditiveOp4316);
+ this_MathOp_0=ruleMathOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_MathOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1995:1: ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )*
+ loop35:
+ do {
+ int alt35=2;
+ int LA35_0 = input.LA(1);
+
+ if ( (LA35_0==RULE_PLUS) ) {
+ int LA35_2 = input.LA(2);
+
+ if ( (synpred22_InternalCoffeeScript()) ) {
+ alt35=1;
+ }
+
+
+ }
+ else if ( (LA35_0==RULE_MINUS) ) {
+ int LA35_3 = input.LA(2);
+
+ if ( (synpred22_InternalCoffeeScript()) ) {
+ alt35=1;
+ }
+
+
+ }
+
+
+ switch (alt35) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1995:2: ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1995:2: ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1995:3: ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2006:6: ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2006:7: () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2006:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2007:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2012:2: ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2013:1: ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2013:1: ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2014:1: (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2014:1: (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS )
+ int alt34=2;
+ int LA34_0 = input.LA(1);
+
+ if ( (LA34_0==RULE_PLUS) ) {
+ alt34=1;
+ }
+ else if ( (LA34_0==RULE_MINUS) ) {
+ alt34=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 34, 0, input);
+
+ throw nvae;
+ }
+ switch (alt34) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2015:3: lv_operator_2_1= RULE_PLUS
+ {
+ lv_operator_2_1=(Token)match(input,RULE_PLUS,FOLLOW_RULE_PLUS_in_ruleAdditiveOp4379); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_1, grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAdditiveOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_1,
+ "PLUS");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2030:8: lv_operator_2_2= RULE_MINUS
+ {
+ lv_operator_2_2=(Token)match(input,RULE_MINUS,FOLLOW_RULE_MINUS_in_ruleAdditiveOp4399); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_2, grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAdditiveOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_2,
+ "MINUS");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2048:4: ( (lv_right_3_0= ruleMathOp ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2049:1: (lv_right_3_0= ruleMathOp )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2049:1: (lv_right_3_0= ruleMathOp )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2050:3: lv_right_3_0= ruleMathOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleMathOp_in_ruleAdditiveOp4430);
+ lv_right_3_0=ruleMathOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAdditiveOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "MathOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop35;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAdditiveOp"
+
+
+ // $ANTLR start "entryRuleMathOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2074:1: entryRuleMathOp returns [EObject current=null] : iv_ruleMathOp= ruleMathOp EOF ;
+ public final EObject entryRuleMathOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleMathOp = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2075:2: (iv_ruleMathOp= ruleMathOp EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2076:2: iv_ruleMathOp= ruleMathOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getMathOpRule());
+ }
+ pushFollow(FOLLOW_ruleMathOp_in_entryRuleMathOp4468);
+ iv_ruleMathOp=ruleMathOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleMathOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleMathOp4478); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleMathOp"
+
+
+ // $ANTLR start "ruleMathOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2083:1: ruleMathOp returns [EObject current=null] : (this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )* ) ;
+ public final EObject ruleMathOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_UnaryOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2086:28: ( (this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2087:1: (this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2087:1: (this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2088:5: this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleUnaryOp_in_ruleMathOp4525);
+ this_UnaryOp_0=ruleUnaryOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_UnaryOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2096:1: ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )*
+ loop36:
+ do {
+ int alt36=2;
+ int LA36_0 = input.LA(1);
+
+ if ( (LA36_0==RULE_MATH) ) {
+ int LA36_2 = input.LA(2);
+
+ if ( (synpred23_InternalCoffeeScript()) ) {
+ alt36=1;
+ }
+
+
+ }
+
+
+ switch (alt36) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2096:2: ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2096:2: ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2096:3: ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2102:6: ( () ( (lv_operator_2_0= RULE_MATH ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2102:7: () ( (lv_operator_2_0= RULE_MATH ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2102:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2103:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2108:2: ( (lv_operator_2_0= RULE_MATH ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2109:1: (lv_operator_2_0= RULE_MATH )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2109:1: (lv_operator_2_0= RULE_MATH )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2110:3: lv_operator_2_0= RULE_MATH
+ {
+ lv_operator_2_0=(Token)match(input,RULE_MATH,FOLLOW_RULE_MATH_in_ruleMathOp4571); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getMathOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "MATH");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2126:4: ( (lv_right_3_0= ruleUnaryOp ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2127:1: (lv_right_3_0= ruleUnaryOp )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2127:1: (lv_right_3_0= ruleUnaryOp )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2128:3: lv_right_3_0= ruleUnaryOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleUnaryOp_in_ruleMathOp4599);
+ lv_right_3_0=ruleUnaryOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getMathOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "UnaryOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop36;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleMathOp"
+
+
+ // $ANTLR start "entryRuleUnaryOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2152:1: entryRuleUnaryOp returns [EObject current=null] : iv_ruleUnaryOp= ruleUnaryOp EOF ;
+ public final EObject entryRuleUnaryOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleUnaryOp = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2153:2: (iv_ruleUnaryOp= ruleUnaryOp EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2154:2: iv_ruleUnaryOp= ruleUnaryOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getUnaryOpRule());
+ }
+ pushFollow(FOLLOW_ruleUnaryOp_in_entryRuleUnaryOp4637);
+ iv_ruleUnaryOp=ruleUnaryOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleUnaryOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleUnaryOp4647); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleUnaryOp"
+
+
+ // $ANTLR start "ruleUnaryOp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2161:1: ruleUnaryOp returns [EObject current=null] : ( ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression ) | ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable ) | (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? ) ) ;
+ public final EObject ruleUnaryOp() throws RecognitionException {
+ EObject current = null;
+
+ Token this_UNARY_0=null;
+ Token this_PLUS_1=null;
+ Token this_MINUS_2=null;
+ Token this_PLUS_PLUS_4=null;
+ Token this_MINUS_MINUS_5=null;
+ Token this_QUESTION_8=null;
+ EObject this_Expression_3 = null;
+
+ EObject this_Variable_6 = null;
+
+ EObject this_Application_7 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2164:28: ( ( ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression ) | ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable ) | (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2165:1: ( ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression ) | ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable ) | (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2165:1: ( ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression ) | ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable ) | (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? ) )
+ int alt40=3;
+ switch ( input.LA(1) ) {
+ case RULE_PLUS:
+ case RULE_MINUS:
+ case RULE_UNARY:
+ {
+ alt40=1;
+ }
+ break;
+ case RULE_PLUS_PLUS:
+ case RULE_MINUS_MINUS:
+ {
+ alt40=2;
+ }
+ break;
+ case RULE_STRING:
+ case RULE_FOR:
+ case RULE_WHILE:
+ case RULE_UNTIL:
+ case RULE_LBRACKET:
+ case RULE_SUPER:
+ case RULE_AT_SIGIL:
+ case RULE_THIS:
+ case RULE_LOOP:
+ case RULE_TRY:
+ case RULE_SWITCH:
+ case RULE_IF:
+ case RULE_IDENTIFIER:
+ case RULE_LCURLY:
+ case RULE_PARAM_START:
+ case RULE_FUNC_ARROW:
+ case RULE_BOUND_FUNC_ARROW:
+ case RULE_NUMBER:
+ case RULE_BOOL:
+ case RULE_JS:
+ case RULE_REGEX:
+ case RULE_LPAREN:
+ {
+ alt40=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 40, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt40) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2165:2: ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2165:2: ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2165:3: (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2165:3: (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS )
+ int alt37=3;
+ switch ( input.LA(1) ) {
+ case RULE_UNARY:
+ {
+ alt37=1;
+ }
+ break;
+ case RULE_PLUS:
+ {
+ alt37=2;
+ }
+ break;
+ case RULE_MINUS:
+ {
+ alt37=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 37, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt37) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2165:4: this_UNARY_0= RULE_UNARY
+ {
+ this_UNARY_0=(Token)match(input,RULE_UNARY,FOLLOW_RULE_UNARY_in_ruleUnaryOp4685); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_UNARY_0, grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2170:6: this_PLUS_1= RULE_PLUS
+ {
+ this_PLUS_1=(Token)match(input,RULE_PLUS,FOLLOW_RULE_PLUS_in_ruleUnaryOp4701); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PLUS_1, grammarAccess.getUnaryOpAccess().getPLUSTerminalRuleCall_0_0_1());
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2175:6: this_MINUS_2= RULE_MINUS
+ {
+ this_MINUS_2=(Token)match(input,RULE_MINUS,FOLLOW_RULE_MINUS_in_ruleUnaryOp4717); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_MINUS_2, grammarAccess.getUnaryOpAccess().getMINUSTerminalRuleCall_0_0_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleUnaryOp4739);
+ this_Expression_3=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Expression_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2189:6: ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2189:6: ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2189:7: (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2189:7: (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS )
+ int alt38=2;
+ int LA38_0 = input.LA(1);
+
+ if ( (LA38_0==RULE_PLUS_PLUS) ) {
+ alt38=1;
+ }
+ else if ( (LA38_0==RULE_MINUS_MINUS) ) {
+ alt38=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 38, 0, input);
+
+ throw nvae;
+ }
+ switch (alt38) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2189:8: this_PLUS_PLUS_4= RULE_PLUS_PLUS
+ {
+ this_PLUS_PLUS_4=(Token)match(input,RULE_PLUS_PLUS,FOLLOW_RULE_PLUS_PLUS_in_ruleUnaryOp4758); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PLUS_PLUS_4, grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2194:6: this_MINUS_MINUS_5= RULE_MINUS_MINUS
+ {
+ this_MINUS_MINUS_5=(Token)match(input,RULE_MINUS_MINUS,FOLLOW_RULE_MINUS_MINUS_in_ruleUnaryOp4774); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_MINUS_MINUS_5, grammarAccess.getUnaryOpAccess().getMINUS_MINUSTerminalRuleCall_1_0_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1());
+
+ }
+ pushFollow(FOLLOW_ruleVariable_in_ruleUnaryOp4796);
+ this_Variable_6=ruleVariable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Variable_6;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2208:6: (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2208:6: (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2209:5: this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )?
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleApplication_in_ruleUnaryOp4825);
+ this_Application_7=ruleApplication();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Application_7;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2217:1: (this_QUESTION_8= RULE_QUESTION )?
+ int alt39=2;
+ int LA39_0 = input.LA(1);
+
+ if ( (LA39_0==RULE_QUESTION) ) {
+ alt39=1;
+ }
+ switch (alt39) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2217:2: this_QUESTION_8= RULE_QUESTION
+ {
+ this_QUESTION_8=(Token)match(input,RULE_QUESTION,FOLLOW_RULE_QUESTION_in_ruleUnaryOp4836); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_QUESTION_8, grammarAccess.getUnaryOpAccess().getQUESTIONTerminalRuleCall_2_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleUnaryOp"
+
+
+ // $ANTLR start "entryRuleApplication"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2229:1: entryRuleApplication returns [EObject current=null] : iv_ruleApplication= ruleApplication EOF ;
+ public final EObject entryRuleApplication() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleApplication = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2230:2: (iv_ruleApplication= ruleApplication EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2231:2: iv_ruleApplication= ruleApplication EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getApplicationRule());
+ }
+ pushFollow(FOLLOW_ruleApplication_in_entryRuleApplication4874);
+ iv_ruleApplication=ruleApplication();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleApplication;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleApplication4884); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleApplication"
+
+
+ // $ANTLR start "ruleApplication"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2238:1: ruleApplication returns [EObject current=null] : ( ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) ) | ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* ) ) ;
+ public final EObject ruleApplication() throws RecognitionException {
+ EObject current = null;
+
+ Token this_SUPER_1=null;
+ Token this_CALL_START_2=null;
+ Token this_CALL_END_4=null;
+ EObject lv_args_3_0 = null;
+
+ EObject lv_value_5_0 = null;
+
+ EObject lv_features_6_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2241:28: ( ( ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) ) | ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2242:1: ( ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) ) | ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2242:1: ( ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) ) | ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* ) )
+ int alt43=2;
+ int LA43_0 = input.LA(1);
+
+ if ( (LA43_0==RULE_SUPER) ) {
+ alt43=1;
+ }
+ else if ( (LA43_0==RULE_STRING||(LA43_0>=RULE_FOR && LA43_0<=RULE_WHILE)||LA43_0==RULE_UNTIL||LA43_0==RULE_LBRACKET||LA43_0==RULE_AT_SIGIL||(LA43_0>=RULE_THIS && LA43_0<=RULE_TRY)||LA43_0==RULE_SWITCH||(LA43_0>=RULE_IF && LA43_0<=RULE_LCURLY)||LA43_0==RULE_PARAM_START||(LA43_0>=RULE_FUNC_ARROW && LA43_0<=RULE_LPAREN)) ) {
+ alt43=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 43, 0, input);
+
+ throw nvae;
+ }
+ switch (alt43) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2242:2: ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2242:2: ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2242:3: () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2242:3: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2243:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getApplicationAccess().getSuperCallAction_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2248:2: (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2248:3: this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )?
+ {
+ this_SUPER_1=(Token)match(input,RULE_SUPER,FOLLOW_RULE_SUPER_in_ruleApplication4931); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_SUPER_1, grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2252:1: (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )?
+ int alt41=2;
+ int LA41_0 = input.LA(1);
+
+ if ( (LA41_0==RULE_CALL_START) ) {
+ alt41=1;
+ }
+ switch (alt41) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2252:2: this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END
+ {
+ this_CALL_START_2=(Token)match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_ruleApplication4942); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_START_2, grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2256:1: ( (lv_args_3_0= ruleArgList ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2257:1: (lv_args_3_0= ruleArgList )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2257:1: (lv_args_3_0= ruleArgList )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2258:3: lv_args_3_0= ruleArgList
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgList_in_ruleApplication4962);
+ lv_args_3_0=ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ set(
+ current,
+ "args",
+ lv_args_3_0,
+ "ArgList");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_CALL_END_4=(Token)match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_ruleApplication4973); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_END_4, grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2279:6: ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2279:6: ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2279:7: ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )*
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2279:7: ( (lv_value_5_0= rulePrimaryExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2280:1: (lv_value_5_0= rulePrimaryExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2280:1: (lv_value_5_0= rulePrimaryExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2281:3: lv_value_5_0= rulePrimaryExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0());
+
+ }
+ pushFollow(FOLLOW_rulePrimaryExpression_in_ruleApplication5004);
+ lv_value_5_0=rulePrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_5_0,
+ "PrimaryExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2297:2: ( (lv_features_6_0= ruleFeatureCall ) )*
+ loop42:
+ do {
+ int alt42=2;
+ int LA42_0 = input.LA(1);
+
+ if ( (LA42_0==RULE_CALL_START||LA42_0==RULE_FUNC_EXIST||(LA42_0>=RULE_DOT && LA42_0<=RULE_INDEX_START)) ) {
+ alt42=1;
+ }
+
+
+ switch (alt42) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2298:1: (lv_features_6_0= ruleFeatureCall )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2298:1: (lv_features_6_0= ruleFeatureCall )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2299:3: lv_features_6_0= ruleFeatureCall
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleFeatureCall_in_ruleApplication5025);
+ lv_features_6_0=ruleFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ add(
+ current,
+ "features",
+ lv_features_6_0,
+ "FeatureCall");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop42;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleApplication"
+
+
+ // $ANTLR start "entryRuleFeatureCall"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2323:1: entryRuleFeatureCall returns [EObject current=null] : iv_ruleFeatureCall= ruleFeatureCall EOF ;
+ public final EObject entryRuleFeatureCall() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleFeatureCall = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2324:2: (iv_ruleFeatureCall= ruleFeatureCall EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2325:2: iv_ruleFeatureCall= ruleFeatureCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getFeatureCallRule());
+ }
+ pushFollow(FOLLOW_ruleFeatureCall_in_entryRuleFeatureCall5063);
+ iv_ruleFeatureCall=ruleFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleFeatureCall;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleFeatureCall5073); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleFeatureCall"
+
+
+ // $ANTLR start "ruleFeatureCall"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2332:1: ruleFeatureCall returns [EObject current=null] : (this_FunctionCall_0= ruleFunctionCall | this_PropertyAccess_1= rulePropertyAccess ) ;
+ public final EObject ruleFeatureCall() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_FunctionCall_0 = null;
+
+ EObject this_PropertyAccess_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2335:28: ( (this_FunctionCall_0= ruleFunctionCall | this_PropertyAccess_1= rulePropertyAccess ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2336:1: (this_FunctionCall_0= ruleFunctionCall | this_PropertyAccess_1= rulePropertyAccess )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2336:1: (this_FunctionCall_0= ruleFunctionCall | this_PropertyAccess_1= rulePropertyAccess )
+ int alt44=2;
+ int LA44_0 = input.LA(1);
+
+ if ( (LA44_0==RULE_CALL_START||LA44_0==RULE_FUNC_EXIST) ) {
+ alt44=1;
+ }
+ else if ( ((LA44_0>=RULE_DOT && LA44_0<=RULE_INDEX_START)) ) {
+ alt44=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 44, 0, input);
+
+ throw nvae;
+ }
+ switch (alt44) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2337:5: this_FunctionCall_0= ruleFunctionCall
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleFunctionCall_in_ruleFeatureCall5120);
+ this_FunctionCall_0=ruleFunctionCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_FunctionCall_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2347:5: this_PropertyAccess_1= rulePropertyAccess
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_rulePropertyAccess_in_ruleFeatureCall5147);
+ this_PropertyAccess_1=rulePropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_PropertyAccess_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleFeatureCall"
+
+
+ // $ANTLR start "entryRuleFunctionCall"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2363:1: entryRuleFunctionCall returns [EObject current=null] : iv_ruleFunctionCall= ruleFunctionCall EOF ;
+ public final EObject entryRuleFunctionCall() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleFunctionCall = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2364:2: (iv_ruleFunctionCall= ruleFunctionCall EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2365:2: iv_ruleFunctionCall= ruleFunctionCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getFunctionCallRule());
+ }
+ pushFollow(FOLLOW_ruleFunctionCall_in_entryRuleFunctionCall5182);
+ iv_ruleFunctionCall=ruleFunctionCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleFunctionCall;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleFunctionCall5192); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleFunctionCall"
+
+
+ // $ANTLR start "ruleFunctionCall"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2372:1: ruleFunctionCall returns [EObject current=null] : ( () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END ) ;
+ public final EObject ruleFunctionCall() throws RecognitionException {
+ EObject current = null;
+
+ Token this_FUNC_EXIST_1=null;
+ Token this_CALL_START_2=null;
+ Token this_CALL_END_4=null;
+ EObject lv_args_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2375:28: ( ( () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2376:1: ( () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2376:1: ( () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2376:2: () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2376:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2377:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getFunctionCallAccess().getFunctionCallAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2382:2: (this_FUNC_EXIST_1= RULE_FUNC_EXIST )?
+ int alt45=2;
+ int LA45_0 = input.LA(1);
+
+ if ( (LA45_0==RULE_FUNC_EXIST) ) {
+ alt45=1;
+ }
+ switch (alt45) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2382:3: this_FUNC_EXIST_1= RULE_FUNC_EXIST
+ {
+ this_FUNC_EXIST_1=(Token)match(input,RULE_FUNC_EXIST,FOLLOW_RULE_FUNC_EXIST_in_ruleFunctionCall5238); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FUNC_EXIST_1, grammarAccess.getFunctionCallAccess().getFUNC_EXISTTerminalRuleCall_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+ this_CALL_START_2=(Token)match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_ruleFunctionCall5250); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_START_2, grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2390:1: ( (lv_args_3_0= ruleArgList ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2391:1: (lv_args_3_0= ruleArgList )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2391:1: (lv_args_3_0= ruleArgList )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2392:3: lv_args_3_0= ruleArgList
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgList_in_ruleFunctionCall5270);
+ lv_args_3_0=ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getFunctionCallRule());
+ }
+ set(
+ current,
+ "args",
+ lv_args_3_0,
+ "ArgList");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_CALL_END_4=(Token)match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_ruleFunctionCall5281); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_END_4, grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleFunctionCall"
+
+
+ // $ANTLR start "entryRulePropertyAccess"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2420:1: entryRulePropertyAccess returns [EObject current=null] : iv_rulePropertyAccess= rulePropertyAccess EOF ;
+ public final EObject entryRulePropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_rulePropertyAccess = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2421:2: (iv_rulePropertyAccess= rulePropertyAccess EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2422:2: iv_rulePropertyAccess= rulePropertyAccess EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getPropertyAccessRule());
+ }
+ pushFollow(FOLLOW_rulePropertyAccess_in_entryRulePropertyAccess5316);
+ iv_rulePropertyAccess=rulePropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_rulePropertyAccess;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRulePropertyAccess5326); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRulePropertyAccess"
+
+
+ // $ANTLR start "rulePropertyAccess"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2429:1: rulePropertyAccess returns [EObject current=null] : (this_NamedPropertyAccess_0= ruleNamedPropertyAccess | this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess ) ;
+ public final EObject rulePropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_NamedPropertyAccess_0 = null;
+
+ EObject this_IndexedPropertyAccess_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2432:28: ( (this_NamedPropertyAccess_0= ruleNamedPropertyAccess | this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2433:1: (this_NamedPropertyAccess_0= ruleNamedPropertyAccess | this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2433:1: (this_NamedPropertyAccess_0= ruleNamedPropertyAccess | this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess )
+ int alt46=2;
+ int LA46_0 = input.LA(1);
+
+ if ( ((LA46_0>=RULE_DOT && LA46_0<=RULE_DOUBLE_COLON)) ) {
+ alt46=1;
+ }
+ else if ( (LA46_0==RULE_INDEX_START) ) {
+ alt46=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 46, 0, input);
+
+ throw nvae;
+ }
+ switch (alt46) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2434:5: this_NamedPropertyAccess_0= ruleNamedPropertyAccess
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleNamedPropertyAccess_in_rulePropertyAccess5373);
+ this_NamedPropertyAccess_0=ruleNamedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_NamedPropertyAccess_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2444:5: this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleIndexedPropertyAccess_in_rulePropertyAccess5400);
+ this_IndexedPropertyAccess_1=ruleIndexedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IndexedPropertyAccess_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "rulePropertyAccess"
+
+
+ // $ANTLR start "entryRuleThisProperty"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2460:1: entryRuleThisProperty returns [EObject current=null] : iv_ruleThisProperty= ruleThisProperty EOF ;
+ public final EObject entryRuleThisProperty() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleThisProperty = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2461:2: (iv_ruleThisProperty= ruleThisProperty EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2462:2: iv_ruleThisProperty= ruleThisProperty EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getThisPropertyRule());
+ }
+ pushFollow(FOLLOW_ruleThisProperty_in_entryRuleThisProperty5435);
+ iv_ruleThisProperty=ruleThisProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleThisProperty;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleThisProperty5445); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleThisProperty"
+
+
+ // $ANTLR start "ruleThisProperty"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2469:1: ruleThisProperty returns [EObject current=null] : (this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId ) ;
+ public final EObject ruleThisProperty() throws RecognitionException {
+ EObject current = null;
+
+ Token this_AT_SIGIL_0=null;
+ EObject this_Id_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2472:28: ( (this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2473:1: (this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2473:1: (this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2473:2: this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId
+ {
+ this_AT_SIGIL_0=(Token)match(input,RULE_AT_SIGIL,FOLLOW_RULE_AT_SIGIL_in_ruleThisProperty5481); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_AT_SIGIL_0, grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleThisProperty5502);
+ this_Id_1=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleThisProperty"
+
+
+ // $ANTLR start "entryRuleNamedPropertyAccess"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2494:1: entryRuleNamedPropertyAccess returns [EObject current=null] : iv_ruleNamedPropertyAccess= ruleNamedPropertyAccess EOF ;
+ public final EObject entryRuleNamedPropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleNamedPropertyAccess = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2495:2: (iv_ruleNamedPropertyAccess= ruleNamedPropertyAccess EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2496:2: iv_ruleNamedPropertyAccess= ruleNamedPropertyAccess EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getNamedPropertyAccessRule());
+ }
+ pushFollow(FOLLOW_ruleNamedPropertyAccess_in_entryRuleNamedPropertyAccess5537);
+ iv_ruleNamedPropertyAccess=ruleNamedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleNamedPropertyAccess;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleNamedPropertyAccess5547); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleNamedPropertyAccess"
+
+
+ // $ANTLR start "ruleNamedPropertyAccess"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2503:1: ruleNamedPropertyAccess returns [EObject current=null] : ( ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) ) | ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? ) ) ;
+ public final EObject ruleNamedPropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_accessor_0_1=null;
+ Token lv_accessor_0_2=null;
+ Token lv_accessor_2_0=null;
+ EObject lv_name_1_0 = null;
+
+ EObject lv_name_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2506:28: ( ( ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) ) | ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2507:1: ( ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) ) | ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2507:1: ( ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) ) | ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? ) )
+ int alt49=2;
+ int LA49_0 = input.LA(1);
+
+ if ( ((LA49_0>=RULE_DOT && LA49_0<=RULE_QUESTION_DOT)) ) {
+ alt49=1;
+ }
+ else if ( (LA49_0==RULE_DOUBLE_COLON) ) {
+ alt49=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 49, 0, input);
+
+ throw nvae;
+ }
+ switch (alt49) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2507:2: ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2507:2: ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2507:3: ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2507:3: ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2508:1: ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2508:1: ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2509:1: (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2509:1: (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT )
+ int alt47=2;
+ int LA47_0 = input.LA(1);
+
+ if ( (LA47_0==RULE_DOT) ) {
+ alt47=1;
+ }
+ else if ( (LA47_0==RULE_QUESTION_DOT) ) {
+ alt47=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 47, 0, input);
+
+ throw nvae;
+ }
+ switch (alt47) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2510:3: lv_accessor_0_1= RULE_DOT
+ {
+ lv_accessor_0_1=(Token)match(input,RULE_DOT,FOLLOW_RULE_DOT_in_ruleNamedPropertyAccess5592); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_0_1, grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_0_1,
+ "DOT");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2525:8: lv_accessor_0_2= RULE_QUESTION_DOT
+ {
+ lv_accessor_0_2=(Token)match(input,RULE_QUESTION_DOT,FOLLOW_RULE_QUESTION_DOT_in_ruleNamedPropertyAccess5612); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_0_2, grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_0_2,
+ "QUESTION_DOT");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2543:2: ( (lv_name_1_0= ruleId ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2544:1: (lv_name_1_0= ruleId )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2544:1: (lv_name_1_0= ruleId )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2545:3: lv_name_1_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleNamedPropertyAccess5641);
+ lv_name_1_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getNamedPropertyAccessRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_1_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2562:6: ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2562:6: ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2562:7: ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2562:7: ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2563:1: (lv_accessor_2_0= RULE_DOUBLE_COLON )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2563:1: (lv_accessor_2_0= RULE_DOUBLE_COLON )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2564:3: lv_accessor_2_0= RULE_DOUBLE_COLON
+ {
+ lv_accessor_2_0=(Token)match(input,RULE_DOUBLE_COLON,FOLLOW_RULE_DOUBLE_COLON_in_ruleNamedPropertyAccess5666); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_2_0, grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_2_0,
+ "DOUBLE_COLON");
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2580:2: ( (lv_name_3_0= ruleId ) )?
+ int alt48=2;
+ int LA48_0 = input.LA(1);
+
+ if ( (LA48_0==RULE_IDENTIFIER) ) {
+ alt48=1;
+ }
+ switch (alt48) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2581:1: (lv_name_3_0= ruleId )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2581:1: (lv_name_3_0= ruleId )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2582:3: lv_name_3_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleNamedPropertyAccess5692);
+ lv_name_3_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getNamedPropertyAccessRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_3_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleNamedPropertyAccess"
+
+
+ // $ANTLR start "entryRuleIndexedPropertyAccess"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2606:1: entryRuleIndexedPropertyAccess returns [EObject current=null] : iv_ruleIndexedPropertyAccess= ruleIndexedPropertyAccess EOF ;
+ public final EObject entryRuleIndexedPropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleIndexedPropertyAccess = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2607:2: (iv_ruleIndexedPropertyAccess= ruleIndexedPropertyAccess EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2608:2: iv_ruleIndexedPropertyAccess= ruleIndexedPropertyAccess EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIndexedPropertyAccessRule());
+ }
+ pushFollow(FOLLOW_ruleIndexedPropertyAccess_in_entryRuleIndexedPropertyAccess5730);
+ iv_ruleIndexedPropertyAccess=ruleIndexedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleIndexedPropertyAccess;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIndexedPropertyAccess5740); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleIndexedPropertyAccess"
+
+
+ // $ANTLR start "ruleIndexedPropertyAccess"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2615:1: ruleIndexedPropertyAccess returns [EObject current=null] : (this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END ) ;
+ public final EObject ruleIndexedPropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDEX_START_0=null;
+ Token this_INDEX_END_2=null;
+ EObject lv_index_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2618:28: ( (this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2619:1: (this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2619:1: (this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2619:2: this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END
+ {
+ this_INDEX_START_0=(Token)match(input,RULE_INDEX_START,FOLLOW_RULE_INDEX_START_in_ruleIndexedPropertyAccess5776); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDEX_START_0, grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2623:1: ( (lv_index_1_0= ruleIndex ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2624:1: (lv_index_1_0= ruleIndex )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2624:1: (lv_index_1_0= ruleIndex )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2625:3: lv_index_1_0= ruleIndex
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleIndex_in_ruleIndexedPropertyAccess5796);
+ lv_index_1_0=ruleIndex();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexedPropertyAccessRule());
+ }
+ set(
+ current,
+ "index",
+ lv_index_1_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_INDEX_END_2=(Token)match(input,RULE_INDEX_END,FOLLOW_RULE_INDEX_END_in_ruleIndexedPropertyAccess5807); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDEX_END_2, grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleIndexedPropertyAccess"
+
+
+ // $ANTLR start "entryRuleIndex"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2653:1: entryRuleIndex returns [EObject current=null] : iv_ruleIndex= ruleIndex EOF ;
+ public final EObject entryRuleIndex() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleIndex = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2654:2: (iv_ruleIndex= ruleIndex EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2655:2: iv_ruleIndex= ruleIndex EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIndexRule());
+ }
+ pushFollow(FOLLOW_ruleIndex_in_entryRuleIndex5842);
+ iv_ruleIndex=ruleIndex();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleIndex;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIndex5852); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleIndex"
+
+
+ // $ANTLR start "ruleIndex"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2662:1: ruleIndex returns [EObject current=null] : ( ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) ) ;
+ public final EObject ruleIndex() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_dots_0_1=null;
+ Token lv_dots_0_2=null;
+ Token lv_dots_3_1=null;
+ Token lv_dots_3_2=null;
+ EObject lv_end_1_0 = null;
+
+ EObject lv_start_2_0 = null;
+
+ EObject lv_end_4_0 = null;
+
+ EObject lv_exp_5_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2665:28: ( ( ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2666:1: ( ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2666:1: ( ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) )
+ int alt53=3;
+ alt53 = dfa53.predict(input);
+ switch (alt53) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2666:2: ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2666:2: ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2666:3: ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2666:3: ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2666:4: ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2677:1: ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2678:1: (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2678:1: (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS )
+ int alt50=2;
+ int LA50_0 = input.LA(1);
+
+ if ( (LA50_0==RULE_DOT_DOT) ) {
+ alt50=1;
+ }
+ else if ( (LA50_0==RULE_ELLIPSIS) ) {
+ alt50=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 50, 0, input);
+
+ throw nvae;
+ }
+ switch (alt50) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2679:3: lv_dots_0_1= RULE_DOT_DOT
+ {
+ lv_dots_0_1=(Token)match(input,RULE_DOT_DOT,FOLLOW_RULE_DOT_DOT_in_ruleIndex5923); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_dots_0_1, grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ current,
+ "dots",
+ lv_dots_0_1,
+ "DOT_DOT");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2694:8: lv_dots_0_2= RULE_ELLIPSIS
+ {
+ lv_dots_0_2=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleIndex5943); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_dots_0_2, grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ current,
+ "dots",
+ lv_dots_0_2,
+ "ELLIPSIS");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2712:2: ( (lv_end_1_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2713:1: (lv_end_1_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2713:1: (lv_end_1_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2714:3: lv_end_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleIndex5972);
+ lv_end_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ current,
+ "end",
+ lv_end_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:6: ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:6: ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:7: ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:7: ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:8: ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2745:6: ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2745:7: ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2745:7: ( (lv_start_2_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2746:1: (lv_start_2_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2746:1: (lv_start_2_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2747:3: lv_start_2_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleIndex6042);
+ lv_start_2_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ current,
+ "start",
+ lv_start_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2763:2: ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2764:1: ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2764:1: ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2765:1: (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2765:1: (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS )
+ int alt51=2;
+ int LA51_0 = input.LA(1);
+
+ if ( (LA51_0==RULE_DOT_DOT) ) {
+ alt51=1;
+ }
+ else if ( (LA51_0==RULE_ELLIPSIS) ) {
+ alt51=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 51, 0, input);
+
+ throw nvae;
+ }
+ switch (alt51) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2766:3: lv_dots_3_1= RULE_DOT_DOT
+ {
+ lv_dots_3_1=(Token)match(input,RULE_DOT_DOT,FOLLOW_RULE_DOT_DOT_in_ruleIndex6061); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_dots_3_1, grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ current,
+ "dots",
+ lv_dots_3_1,
+ "DOT_DOT");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2781:8: lv_dots_3_2= RULE_ELLIPSIS
+ {
+ lv_dots_3_2=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleIndex6081); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_dots_3_2, grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ current,
+ "dots",
+ lv_dots_3_2,
+ "ELLIPSIS");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2799:4: ( (lv_end_4_0= ruleExpression ) )?
+ int alt52=2;
+ int LA52_0 = input.LA(1);
+
+ if ( (LA52_0==RULE_STRING||(LA52_0>=RULE_FOR && LA52_0<=RULE_WHILE)||LA52_0==RULE_UNTIL||LA52_0==RULE_LBRACKET||(LA52_0>=RULE_PLUS && LA52_0<=RULE_MINUS)||(LA52_0>=RULE_UNARY && LA52_0<=RULE_MINUS_MINUS)||LA52_0==RULE_SUPER||LA52_0==RULE_AT_SIGIL||(LA52_0>=RULE_THIS && LA52_0<=RULE_TRY)||LA52_0==RULE_SWITCH||(LA52_0>=RULE_IF && LA52_0<=RULE_LCURLY)||LA52_0==RULE_PARAM_START||(LA52_0>=RULE_FUNC_ARROW && LA52_0<=RULE_LPAREN)) ) {
+ alt52=1;
+ }
+ switch (alt52) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2800:1: (lv_end_4_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2800:1: (lv_end_4_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2801:3: lv_end_4_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleIndex6112);
+ lv_end_4_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ current,
+ "end",
+ lv_end_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2818:6: ( (lv_exp_5_0= ruleExpression ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2818:6: ( (lv_exp_5_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2819:1: (lv_exp_5_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2819:1: (lv_exp_5_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2820:3: lv_exp_5_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleIndex6141);
+ lv_exp_5_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ current,
+ "exp",
+ lv_exp_5_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleIndex"
+
+
+ // $ANTLR start "entryRulePrimaryExpression"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2844:1: entryRulePrimaryExpression returns [EObject current=null] : iv_rulePrimaryExpression= rulePrimaryExpression EOF ;
+ public final EObject entryRulePrimaryExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_rulePrimaryExpression = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2845:2: (iv_rulePrimaryExpression= rulePrimaryExpression EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2846:2: iv_rulePrimaryExpression= rulePrimaryExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getPrimaryExpressionRule());
+ }
+ pushFollow(FOLLOW_rulePrimaryExpression_in_entryRulePrimaryExpression6177);
+ iv_rulePrimaryExpression=rulePrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_rulePrimaryExpression;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRulePrimaryExpression6187); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRulePrimaryExpression"
+
+
+ // $ANTLR start "rulePrimaryExpression"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2853:1: rulePrimaryExpression returns [EObject current=null] : (this_IfExp_0= ruleIfExp | this_Parenthetical_1= ruleParenthetical | this_Literal_2= ruleLiteral | ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef ) ;
+ public final EObject rulePrimaryExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token this_THIS_9=null;
+ Token this_FOR_11=null;
+ Token this_WHILE_15=null;
+ Token this_WHEN_17=null;
+ Token this_UNTIL_21=null;
+ Token this_WHEN_23=null;
+ Token this_LOOP_27=null;
+ Token this_TRY_30=null;
+ Token this_CATCH_32=null;
+ Token this_FINALLY_35=null;
+ Token this_FINALLY_37=null;
+ Token this_SWITCH_40=null;
+ Token this_INDENT_42=null;
+ Token this_ELSE_44=null;
+ Token this_OUTDENT_46=null;
+ EObject this_IfExp_0 = null;
+
+ EObject this_Parenthetical_1 = null;
+
+ EObject this_Literal_2 = null;
+
+ EObject this_Range_3 = null;
+
+ EObject this_Array_4 = null;
+
+ EObject this_Dictionary_5 = null;
+
+ EObject this_Lambda_6 = null;
+
+ EObject this_ThisProperty_7 = null;
+
+ EObject lv_loop_12_0 = null;
+
+ EObject lv_body_13_0 = null;
+
+ EObject lv_loop_16_0 = null;
+
+ EObject lv_when_18_0 = null;
+
+ EObject lv_body_19_0 = null;
+
+ EObject lv_loop_22_0 = null;
+
+ EObject lv_when_24_0 = null;
+
+ EObject lv_body_25_0 = null;
+
+ EObject lv_body_28_0 = null;
+
+ EObject lv_body_31_0 = null;
+
+ EObject lv_exception_33_0 = null;
+
+ EObject lv_catchBlock_34_0 = null;
+
+ EObject lv_finallyBlock_36_0 = null;
+
+ EObject lv_finallyBlock_38_0 = null;
+
+ EObject lv_exp_41_0 = null;
+
+ EObject lv_cases_43_0 = null;
+
+ EObject lv_elseBlock_45_0 = null;
+
+ EObject this_IdRef_47 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2856:28: ( (this_IfExp_0= ruleIfExp | this_Parenthetical_1= ruleParenthetical | this_Literal_2= ruleLiteral | ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2857:1: (this_IfExp_0= ruleIfExp | this_Parenthetical_1= ruleParenthetical | this_Literal_2= ruleLiteral | ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2857:1: (this_IfExp_0= ruleIfExp | this_Parenthetical_1= ruleParenthetical | this_Literal_2= ruleLiteral | ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef )
+ int alt61=16;
+ alt61 = dfa61.predict(input);
+ switch (alt61) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2858:5: this_IfExp_0= ruleIfExp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleIfExp_in_rulePrimaryExpression6234);
+ this_IfExp_0=ruleIfExp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IfExp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2868:5: this_Parenthetical_1= ruleParenthetical
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleParenthetical_in_rulePrimaryExpression6261);
+ this_Parenthetical_1=ruleParenthetical();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Parenthetical_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2878:5: this_Literal_2= ruleLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleLiteral_in_rulePrimaryExpression6288);
+ this_Literal_2=ruleLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Literal_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 4 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2887:6: ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2887:6: ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2887:7: ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3());
+
+ }
+ pushFollow(FOLLOW_ruleRange_in_rulePrimaryExpression6344);
+ this_Range_3=ruleRange();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Range_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2902:6: ( ( RULE_LBRACKET )=>this_Array_4= ruleArray )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2902:6: ( ( RULE_LBRACKET )=>this_Array_4= ruleArray )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2902:7: ( RULE_LBRACKET )=>this_Array_4= ruleArray
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4());
+
+ }
+ pushFollow(FOLLOW_ruleArray_in_rulePrimaryExpression6378);
+ this_Array_4=ruleArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Array_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 6 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2912:6: ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2912:6: ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2912:7: ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5());
+
+ }
+ pushFollow(FOLLOW_ruleDictionary_in_rulePrimaryExpression6412);
+ this_Dictionary_5=ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Dictionary_5;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2923:5: this_Lambda_6= ruleLambda
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6());
+
+ }
+ pushFollow(FOLLOW_ruleLambda_in_rulePrimaryExpression6440);
+ this_Lambda_6=ruleLambda();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Lambda_6;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 8 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2933:5: this_ThisProperty_7= ruleThisProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7());
+
+ }
+ pushFollow(FOLLOW_ruleThisProperty_in_rulePrimaryExpression6467);
+ this_ThisProperty_7=ruleThisProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ThisProperty_7;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 9 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2942:6: ( () this_THIS_9= RULE_THIS )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2942:6: ( () this_THIS_9= RULE_THIS )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2942:7: () this_THIS_9= RULE_THIS
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2942:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2943:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0(),
+ current);
+
+ }
+
+ }
+
+ this_THIS_9=(Token)match(input,RULE_THIS,FOLLOW_RULE_THIS_in_rulePrimaryExpression6493); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_THIS_9, grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 10 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2953:6: ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2953:6: ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2953:7: () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2953:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2954:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getForAction_9_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2959:2: (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2959:3: this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) )
+ {
+ this_FOR_11=(Token)match(input,RULE_FOR,FOLLOW_RULE_FOR_in_rulePrimaryExpression6521); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FOR_11, grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2963:1: ( (lv_loop_12_0= ruleForBody ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2964:1: (lv_loop_12_0= ruleForBody )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2964:1: (lv_loop_12_0= ruleForBody )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2965:3: lv_loop_12_0= ruleForBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleForBody_in_rulePrimaryExpression6541);
+ lv_loop_12_0=ruleForBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "loop",
+ lv_loop_12_0,
+ "ForBody");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2981:2: ( (lv_body_13_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2982:1: (lv_body_13_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2982:1: (lv_body_13_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2983:3: lv_body_13_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6562);
+ lv_body_13_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_13_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 11 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3000:6: ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3000:6: ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3000:7: () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3000:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3001:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3006:2: (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3006:3: this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) )
+ {
+ this_WHILE_15=(Token)match(input,RULE_WHILE,FOLLOW_RULE_WHILE_in_rulePrimaryExpression6592); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHILE_15, grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3010:1: ( (lv_loop_16_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3011:1: (lv_loop_16_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3011:1: (lv_loop_16_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3012:3: lv_loop_16_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression6612);
+ lv_loop_16_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "loop",
+ lv_loop_16_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3028:2: (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )?
+ int alt54=2;
+ int LA54_0 = input.LA(1);
+
+ if ( (LA54_0==RULE_WHEN) ) {
+ alt54=1;
+ }
+ switch (alt54) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3028:3: this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) )
+ {
+ this_WHEN_17=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rulePrimaryExpression6624); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_17, grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3032:1: ( (lv_when_18_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3033:1: (lv_when_18_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3033:1: (lv_when_18_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3034:3: lv_when_18_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression6644);
+ lv_when_18_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_18_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3050:4: ( (lv_body_19_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3051:1: (lv_body_19_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3051:1: (lv_body_19_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3052:3: lv_body_19_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6667);
+ lv_body_19_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_19_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 12 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3069:6: ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3069:6: ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3069:7: () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3069:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3070:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3075:2: (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3075:3: this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) )
+ {
+ this_UNTIL_21=(Token)match(input,RULE_UNTIL,FOLLOW_RULE_UNTIL_in_rulePrimaryExpression6697); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_UNTIL_21, grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3079:1: ( (lv_loop_22_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3080:1: (lv_loop_22_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3080:1: (lv_loop_22_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3081:3: lv_loop_22_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression6717);
+ lv_loop_22_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "loop",
+ lv_loop_22_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3097:2: (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )?
+ int alt55=2;
+ int LA55_0 = input.LA(1);
+
+ if ( (LA55_0==RULE_WHEN) ) {
+ alt55=1;
+ }
+ switch (alt55) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3097:3: this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) )
+ {
+ this_WHEN_23=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rulePrimaryExpression6729); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_23, grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3101:1: ( (lv_when_24_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3102:1: (lv_when_24_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3102:1: (lv_when_24_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3103:3: lv_when_24_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression6749);
+ lv_when_24_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_24_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3119:4: ( (lv_body_25_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3120:1: (lv_body_25_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3120:1: (lv_body_25_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3121:3: lv_body_25_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6772);
+ lv_body_25_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_25_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 13 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3138:6: ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3138:6: ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3138:7: () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3138:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3139:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3144:2: (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3144:3: this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) )
+ {
+ this_LOOP_27=(Token)match(input,RULE_LOOP,FOLLOW_RULE_LOOP_in_rulePrimaryExpression6802); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LOOP_27, grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3148:1: ( (lv_body_28_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3149:1: (lv_body_28_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3149:1: (lv_body_28_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3150:3: lv_body_28_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6822);
+ lv_body_28_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_28_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 14 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3167:6: ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3167:6: ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3167:7: () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3167:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3168:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3173:2: (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3173:3: this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )?
+ {
+ this_TRY_30=(Token)match(input,RULE_TRY,FOLLOW_RULE_TRY_in_rulePrimaryExpression6852); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TRY_30, grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3177:1: ( (lv_body_31_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3178:1: (lv_body_31_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3178:1: (lv_body_31_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3179:3: lv_body_31_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6872);
+ lv_body_31_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_31_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3195:2: ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )?
+ int alt57=3;
+ int LA57_0 = input.LA(1);
+
+ if ( (LA57_0==RULE_CATCH) ) {
+ alt57=1;
+ }
+ else if ( (LA57_0==RULE_FINALLY) ) {
+ alt57=2;
+ }
+ switch (alt57) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3195:3: (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3195:3: (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3195:4: this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )?
+ {
+ this_CATCH_32=(Token)match(input,RULE_CATCH,FOLLOW_RULE_CATCH_in_rulePrimaryExpression6885); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CATCH_32, grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3199:1: ( (lv_exception_33_0= ruleId ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3200:1: (lv_exception_33_0= ruleId )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3200:1: (lv_exception_33_0= ruleId )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3201:3: lv_exception_33_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_rulePrimaryExpression6905);
+ lv_exception_33_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "exception",
+ lv_exception_33_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3217:2: ( (lv_catchBlock_34_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3218:1: (lv_catchBlock_34_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3218:1: (lv_catchBlock_34_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3219:3: lv_catchBlock_34_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6926);
+ lv_catchBlock_34_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "catchBlock",
+ lv_catchBlock_34_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3235:2: (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )?
+ int alt56=2;
+ int LA56_0 = input.LA(1);
+
+ if ( (LA56_0==RULE_FINALLY) ) {
+ alt56=1;
+ }
+ switch (alt56) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3235:3: this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) )
+ {
+ this_FINALLY_35=(Token)match(input,RULE_FINALLY,FOLLOW_RULE_FINALLY_in_rulePrimaryExpression6938); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FINALLY_35, grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3239:1: ( (lv_finallyBlock_36_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3240:1: (lv_finallyBlock_36_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3240:1: (lv_finallyBlock_36_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3241:3: lv_finallyBlock_36_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6958);
+ lv_finallyBlock_36_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "finallyBlock",
+ lv_finallyBlock_36_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3258:6: (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3258:6: (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3258:7: this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) )
+ {
+ this_FINALLY_37=(Token)match(input,RULE_FINALLY,FOLLOW_RULE_FINALLY_in_rulePrimaryExpression6979); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FINALLY_37, grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3262:1: ( (lv_finallyBlock_38_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3263:1: (lv_finallyBlock_38_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3263:1: (lv_finallyBlock_38_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3264:3: lv_finallyBlock_38_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6999);
+ lv_finallyBlock_38_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "finallyBlock",
+ lv_finallyBlock_38_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 15 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3281:6: ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3281:6: ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3281:7: () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3281:7: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3282:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3287:2: (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3287:3: this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT
+ {
+ this_SWITCH_40=(Token)match(input,RULE_SWITCH,FOLLOW_RULE_SWITCH_in_rulePrimaryExpression7032); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_SWITCH_40, grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3291:1: ( (lv_exp_41_0= ruleExpression ) )?
+ int alt58=2;
+ int LA58_0 = input.LA(1);
+
+ if ( (LA58_0==RULE_STRING||(LA58_0>=RULE_FOR && LA58_0<=RULE_WHILE)||LA58_0==RULE_UNTIL||LA58_0==RULE_LBRACKET||(LA58_0>=RULE_PLUS && LA58_0<=RULE_MINUS)||(LA58_0>=RULE_UNARY && LA58_0<=RULE_MINUS_MINUS)||LA58_0==RULE_SUPER||LA58_0==RULE_AT_SIGIL||(LA58_0>=RULE_THIS && LA58_0<=RULE_TRY)||LA58_0==RULE_SWITCH||(LA58_0>=RULE_IF && LA58_0<=RULE_LCURLY)||LA58_0==RULE_PARAM_START||(LA58_0>=RULE_FUNC_ARROW && LA58_0<=RULE_LPAREN)) ) {
+ alt58=1;
+ }
+ switch (alt58) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3292:1: (lv_exp_41_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3292:1: (lv_exp_41_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3293:3: lv_exp_41_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression7052);
+ lv_exp_41_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "exp",
+ lv_exp_41_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ this_INDENT_42=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rulePrimaryExpression7064); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_42, grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3313:1: ( (lv_cases_43_0= ruleCase ) )*
+ loop59:
+ do {
+ int alt59=2;
+ int LA59_0 = input.LA(1);
+
+ if ( (LA59_0==RULE_LEADING_WHEN) ) {
+ alt59=1;
+ }
+
+
+ switch (alt59) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3314:1: (lv_cases_43_0= ruleCase )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3314:1: (lv_cases_43_0= ruleCase )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3315:3: lv_cases_43_0= ruleCase
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleCase_in_rulePrimaryExpression7084);
+ lv_cases_43_0=ruleCase();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ add(
+ current,
+ "cases",
+ lv_cases_43_0,
+ "Case");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop59;
+ }
+ } while (true);
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3331:3: (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )?
+ int alt60=2;
+ int LA60_0 = input.LA(1);
+
+ if ( (LA60_0==RULE_ELSE) ) {
+ alt60=1;
+ }
+ switch (alt60) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3331:4: this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) )
+ {
+ this_ELSE_44=(Token)match(input,RULE_ELSE,FOLLOW_RULE_ELSE_in_rulePrimaryExpression7097); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_ELSE_44, grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3335:1: ( (lv_elseBlock_45_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3336:1: (lv_elseBlock_45_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3336:1: (lv_elseBlock_45_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3337:3: lv_elseBlock_45_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression7117);
+ lv_elseBlock_45_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "elseBlock",
+ lv_elseBlock_45_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ this_OUTDENT_46=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rulePrimaryExpression7130); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_46, grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5());
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 16 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3359:5: this_IdRef_47= ruleIdRef
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15());
+
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_rulePrimaryExpression7159);
+ this_IdRef_47=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IdRef_47;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "rulePrimaryExpression"
+
+
+ // $ANTLR start "entryRuleBlock"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3375:1: entryRuleBlock returns [EObject current=null] : iv_ruleBlock= ruleBlock EOF ;
+ public final EObject entryRuleBlock() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleBlock = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3376:2: (iv_ruleBlock= ruleBlock EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3377:2: iv_ruleBlock= ruleBlock EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getBlockRule());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_entryRuleBlock7194);
+ iv_ruleBlock=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleBlock;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBlock7204); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleBlock"
+
+
+ // $ANTLR start "ruleBlock"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3384:1: ruleBlock returns [EObject current=null] : ( () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT ) ;
+ public final EObject ruleBlock() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDENT_1=null;
+ Token this_OUTDENT_3=null;
+ EObject this_Body_2 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3387:28: ( ( () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3388:1: ( () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3388:1: ( () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3388:2: () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3388:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3389:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getBlockAccess().getBlockAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_INDENT_1=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleBlock7249); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_1, grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3398:1: (this_Body_2= ruleBody )?
+ int alt62=2;
+ int LA62_0 = input.LA(1);
+
+ if ( ((LA62_0>=RULE_STATEMENT && LA62_0<=RULE_HERECOMMENT)||LA62_0==RULE_STRING||LA62_0==RULE_RETURN||(LA62_0>=RULE_THROW && LA62_0<=RULE_CLASS)||(LA62_0>=RULE_FOR && LA62_0<=RULE_WHILE)||LA62_0==RULE_UNTIL||LA62_0==RULE_LBRACKET||(LA62_0>=RULE_PLUS && LA62_0<=RULE_MINUS)||(LA62_0>=RULE_UNARY && LA62_0<=RULE_MINUS_MINUS)||LA62_0==RULE_SUPER||LA62_0==RULE_AT_SIGIL||(LA62_0>=RULE_THIS && LA62_0<=RULE_TRY)||LA62_0==RULE_SWITCH||(LA62_0>=RULE_IF && LA62_0<=RULE_LCURLY)||LA62_0==RULE_PARAM_START||(LA62_0>=RULE_FUNC_ARROW && LA62_0<=RULE_LPAREN)) ) {
+ alt62=1;
+ }
+ switch (alt62) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3399:5: this_Body_2= ruleBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getBlockAccess().getBodyParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleBody_in_ruleBlock7271);
+ this_Body_2=ruleBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Body_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+ this_OUTDENT_3=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleBlock7283); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_3, grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleBlock"
+
+
+ // $ANTLR start "entryRuleCase"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3419:1: entryRuleCase returns [EObject current=null] : iv_ruleCase= ruleCase EOF ;
+ public final EObject entryRuleCase() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleCase = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3420:2: (iv_ruleCase= ruleCase EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3421:2: iv_ruleCase= ruleCase EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getCaseRule());
+ }
+ pushFollow(FOLLOW_ruleCase_in_entryRuleCase7318);
+ iv_ruleCase=ruleCase();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleCase;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCase7328); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleCase"
+
+
+ // $ANTLR start "ruleCase"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3428:1: ruleCase returns [EObject current=null] : (this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )? ) ;
+ public final EObject ruleCase() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LEADING_WHEN_0=null;
+ Token this_COMMA_2=null;
+ Token this_TERMINATOR_5=null;
+ EObject lv_whens_1_0 = null;
+
+ EObject lv_whens_3_0 = null;
+
+ EObject lv_then_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3431:28: ( (this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3432:1: (this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3432:1: (this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3432:2: this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )?
+ {
+ this_LEADING_WHEN_0=(Token)match(input,RULE_LEADING_WHEN,FOLLOW_RULE_LEADING_WHEN_in_ruleCase7364); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LEADING_WHEN_0, grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3436:1: ( (lv_whens_1_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3437:1: (lv_whens_1_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3437:1: (lv_whens_1_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3438:3: lv_whens_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleCase7384);
+ lv_whens_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ add(
+ current,
+ "whens",
+ lv_whens_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3454:2: (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )*
+ loop63:
+ do {
+ int alt63=2;
+ int LA63_0 = input.LA(1);
+
+ if ( (LA63_0==RULE_COMMA) ) {
+ alt63=1;
+ }
+
+
+ switch (alt63) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3454:3: this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) )
+ {
+ this_COMMA_2=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleCase7396); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_2, grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3458:1: ( (lv_whens_3_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3459:1: (lv_whens_3_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3459:1: (lv_whens_3_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3460:3: lv_whens_3_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleCase7416);
+ lv_whens_3_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ add(
+ current,
+ "whens",
+ lv_whens_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop63;
+ }
+ } while (true);
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3476:4: ( (lv_then_4_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3477:1: (lv_then_4_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3477:1: (lv_then_4_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3478:3: lv_then_4_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleCase7439);
+ lv_then_4_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ set(
+ current,
+ "then",
+ lv_then_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3494:2: (this_TERMINATOR_5= RULE_TERMINATOR )?
+ int alt64=2;
+ int LA64_0 = input.LA(1);
+
+ if ( (LA64_0==RULE_TERMINATOR) ) {
+ alt64=1;
+ }
+ switch (alt64) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3494:3: this_TERMINATOR_5= RULE_TERMINATOR
+ {
+ this_TERMINATOR_5=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleCase7451); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_5, grammarAccess.getCaseAccess().getTERMINATORTerminalRuleCall_4());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleCase"
+
+
+ // $ANTLR start "entryRuleIfExp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3506:1: entryRuleIfExp returns [EObject current=null] : iv_ruleIfExp= ruleIfExp EOF ;
+ public final EObject entryRuleIfExp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleIfExp = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3507:2: (iv_ruleIfExp= ruleIfExp EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3508:2: iv_ruleIfExp= ruleIfExp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIfExpRule());
+ }
+ pushFollow(FOLLOW_ruleIfExp_in_entryRuleIfExp7488);
+ iv_ruleIfExp=ruleIfExp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleIfExp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIfExp7498); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleIfExp"
+
+
+ // $ANTLR start "ruleIfExp"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3515:1: ruleIfExp returns [EObject current=null] : ( ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )? ) ;
+ public final EObject ruleIfExp() throws RecognitionException {
+ EObject current = null;
+
+ Token this_ELSE_1=null;
+ Token this_ELSE_3=null;
+ EObject lv_blocks_0_0 = null;
+
+ EObject lv_blocks_2_0 = null;
+
+ EObject lv_defaultBlock_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3518:28: ( ( ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3519:1: ( ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3519:1: ( ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3519:2: ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3519:2: ( (lv_blocks_0_0= ruleCondBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3520:1: (lv_blocks_0_0= ruleCondBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3520:1: (lv_blocks_0_0= ruleCondBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3521:3: lv_blocks_0_0= ruleCondBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleCondBlock_in_ruleIfExp7544);
+ lv_blocks_0_0=ruleCondBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ add(
+ current,
+ "blocks",
+ lv_blocks_0_0,
+ "CondBlock");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3537:2: (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )*
+ loop65:
+ do {
+ int alt65=2;
+ int LA65_0 = input.LA(1);
+
+ if ( (LA65_0==RULE_ELSE) ) {
+ int LA65_1 = input.LA(2);
+
+ if ( (LA65_1==RULE_IF) ) {
+ alt65=1;
+ }
+
+
+ }
+
+
+ switch (alt65) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3537:3: this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) )
+ {
+ this_ELSE_1=(Token)match(input,RULE_ELSE,FOLLOW_RULE_ELSE_in_ruleIfExp7556); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_ELSE_1, grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3541:1: ( (lv_blocks_2_0= ruleCondBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3542:1: (lv_blocks_2_0= ruleCondBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3542:1: (lv_blocks_2_0= ruleCondBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3543:3: lv_blocks_2_0= ruleCondBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleCondBlock_in_ruleIfExp7576);
+ lv_blocks_2_0=ruleCondBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ add(
+ current,
+ "blocks",
+ lv_blocks_2_0,
+ "CondBlock");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop65;
+ }
+ } while (true);
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3559:4: (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )?
+ int alt66=2;
+ int LA66_0 = input.LA(1);
+
+ if ( (LA66_0==RULE_ELSE) ) {
+ alt66=1;
+ }
+ switch (alt66) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3559:5: this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) )
+ {
+ this_ELSE_3=(Token)match(input,RULE_ELSE,FOLLOW_RULE_ELSE_in_ruleIfExp7590); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_ELSE_3, grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3563:1: ( (lv_defaultBlock_4_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3564:1: (lv_defaultBlock_4_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3564:1: (lv_defaultBlock_4_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3565:3: lv_defaultBlock_4_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleIfExp7610);
+ lv_defaultBlock_4_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ set(
+ current,
+ "defaultBlock",
+ lv_defaultBlock_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleIfExp"
+
+
+ // $ANTLR start "entryRuleCondBlock"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3589:1: entryRuleCondBlock returns [EObject current=null] : iv_ruleCondBlock= ruleCondBlock EOF ;
+ public final EObject entryRuleCondBlock() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleCondBlock = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3590:2: (iv_ruleCondBlock= ruleCondBlock EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3591:2: iv_ruleCondBlock= ruleCondBlock EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getCondBlockRule());
+ }
+ pushFollow(FOLLOW_ruleCondBlock_in_entryRuleCondBlock7648);
+ iv_ruleCondBlock=ruleCondBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleCondBlock;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCondBlock7658); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleCondBlock"
+
+
+ // $ANTLR start "ruleCondBlock"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3598:1: ruleCondBlock returns [EObject current=null] : ( ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) ) ) ;
+ public final EObject ruleCondBlock() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_0_0=null;
+ EObject lv_condition_1_0 = null;
+
+ EObject lv_action_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3601:28: ( ( ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3602:1: ( ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3602:1: ( ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3602:2: ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3602:2: ( (lv_operator_0_0= RULE_IF ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3603:1: (lv_operator_0_0= RULE_IF )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3603:1: (lv_operator_0_0= RULE_IF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3604:3: lv_operator_0_0= RULE_IF
+ {
+ lv_operator_0_0=(Token)match(input,RULE_IF,FOLLOW_RULE_IF_in_ruleCondBlock7700); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_0_0, grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getCondBlockRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_0_0,
+ "IF");
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3620:2: ( (lv_condition_1_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3621:1: (lv_condition_1_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3621:1: (lv_condition_1_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3622:3: lv_condition_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleCondBlock7726);
+ lv_condition_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCondBlockRule());
+ }
+ set(
+ current,
+ "condition",
+ lv_condition_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3638:2: ( (lv_action_2_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3639:1: (lv_action_2_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3639:1: (lv_action_2_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3640:3: lv_action_2_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleCondBlock7747);
+ lv_action_2_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCondBlockRule());
+ }
+ set(
+ current,
+ "action",
+ lv_action_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleCondBlock"
+
+
+ // $ANTLR start "entryRuleIdRef"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3664:1: entryRuleIdRef returns [EObject current=null] : iv_ruleIdRef= ruleIdRef EOF ;
+ public final EObject entryRuleIdRef() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleIdRef = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3665:2: (iv_ruleIdRef= ruleIdRef EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3666:2: iv_ruleIdRef= ruleIdRef EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIdRefRule());
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_entryRuleIdRef7783);
+ iv_ruleIdRef=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleIdRef;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIdRef7793); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleIdRef"
+
+
+ // $ANTLR start "ruleIdRef"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3673:1: ruleIdRef returns [EObject current=null] : ( (otherlv_0= RULE_IDENTIFIER ) ) ;
+ public final EObject ruleIdRef() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3676:28: ( ( (otherlv_0= RULE_IDENTIFIER ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3677:1: ( (otherlv_0= RULE_IDENTIFIER ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3677:1: ( (otherlv_0= RULE_IDENTIFIER ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3678:1: (otherlv_0= RULE_IDENTIFIER )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3678:1: (otherlv_0= RULE_IDENTIFIER )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3679:3: otherlv_0= RULE_IDENTIFIER
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIdRefRule());
+ }
+
+ }
+ otherlv_0=(Token)match(input,RULE_IDENTIFIER,FOLLOW_RULE_IDENTIFIER_in_ruleIdRef7837); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_0, grammarAccess.getIdRefAccess().getValIdCrossReference_0());
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleIdRef"
+
+
+ // $ANTLR start "entryRuleId"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3698:1: entryRuleId returns [EObject current=null] : iv_ruleId= ruleId EOF ;
+ public final EObject entryRuleId() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleId = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3699:2: (iv_ruleId= ruleId EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3700:2: iv_ruleId= ruleId EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIdRule());
+ }
+ pushFollow(FOLLOW_ruleId_in_entryRuleId7872);
+ iv_ruleId=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleId;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleId7882); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleId"
+
+
+ // $ANTLR start "ruleId"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3707:1: ruleId returns [EObject current=null] : ( (lv_name_0_0= RULE_IDENTIFIER ) ) ;
+ public final EObject ruleId() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_name_0_0=null;
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3710:28: ( ( (lv_name_0_0= RULE_IDENTIFIER ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3711:1: ( (lv_name_0_0= RULE_IDENTIFIER ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3711:1: ( (lv_name_0_0= RULE_IDENTIFIER ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3712:1: (lv_name_0_0= RULE_IDENTIFIER )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3712:1: (lv_name_0_0= RULE_IDENTIFIER )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3713:3: lv_name_0_0= RULE_IDENTIFIER
+ {
+ lv_name_0_0=(Token)match(input,RULE_IDENTIFIER,FOLLOW_RULE_IDENTIFIER_in_ruleId7923); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_name_0_0, grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIdRule());
+ }
+ setWithLastConsumed(
+ current,
+ "name",
+ lv_name_0_0,
+ "IDENTIFIER");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleId"
+
+
+ // $ANTLR start "entryRuleProperty"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3737:1: entryRuleProperty returns [EObject current=null] : iv_ruleProperty= ruleProperty EOF ;
+ public final EObject entryRuleProperty() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleProperty = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3738:2: (iv_ruleProperty= ruleProperty EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3739:2: iv_ruleProperty= ruleProperty EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getPropertyRule());
+ }
+ pushFollow(FOLLOW_ruleProperty_in_entryRuleProperty7963);
+ iv_ruleProperty=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleProperty;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleProperty7973); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleProperty"
+
+
+ // $ANTLR start "ruleProperty"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3746:1: ruleProperty returns [EObject current=null] : ( ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) ) | ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END ) ) ;
+ public final EObject ruleProperty() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_accessor_1_1=null;
+ Token lv_accessor_1_2=null;
+ Token lv_accessor_1_3=null;
+ Token this_INDEX_START_4=null;
+ Token this_INDEX_END_6=null;
+ EObject this_IdRef_0 = null;
+
+ EObject lv_prop_2_0 = null;
+
+ EObject this_IdRef_3 = null;
+
+ EObject lv_index_5_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3749:28: ( ( ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) ) | ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:1: ( ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) ) | ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:1: ( ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) ) | ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END ) )
+ int alt68=2;
+ int LA68_0 = input.LA(1);
+
+ if ( (LA68_0==RULE_IDENTIFIER) ) {
+ int LA68_1 = input.LA(2);
+
+ if ( (LA68_1==RULE_INDEX_START) && (synpred30_InternalCoffeeScript())) {
+ alt68=2;
+ }
+ else if ( (LA68_1==RULE_DOT) && (synpred29_InternalCoffeeScript())) {
+ alt68=1;
+ }
+ else if ( (LA68_1==RULE_DOUBLE_COLON) && (synpred29_InternalCoffeeScript())) {
+ alt68=1;
+ }
+ else if ( (LA68_1==RULE_QUESTION_DOT) && (synpred29_InternalCoffeeScript())) {
+ alt68=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 68, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 68, 0, input);
+
+ throw nvae;
+ }
+ switch (alt68) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:2: ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:2: ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:3: ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:3: ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:4: ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3762:6: (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3763:5: this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) )
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_ruleProperty8065);
+ this_IdRef_0=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IdRef_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3771:1: ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3772:1: ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3772:1: ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3773:1: (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3773:1: (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT )
+ int alt67=3;
+ switch ( input.LA(1) ) {
+ case RULE_DOT:
+ {
+ alt67=1;
+ }
+ break;
+ case RULE_DOUBLE_COLON:
+ {
+ alt67=2;
+ }
+ break;
+ case RULE_QUESTION_DOT:
+ {
+ alt67=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 67, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt67) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3774:3: lv_accessor_1_1= RULE_DOT
+ {
+ lv_accessor_1_1=(Token)match(input,RULE_DOT,FOLLOW_RULE_DOT_in_ruleProperty8083); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_1_1, grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_1_1,
+ "DOT");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3789:8: lv_accessor_1_2= RULE_DOUBLE_COLON
+ {
+ lv_accessor_1_2=(Token)match(input,RULE_DOUBLE_COLON,FOLLOW_RULE_DOUBLE_COLON_in_ruleProperty8103); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_1_2, grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_1_2,
+ "DOUBLE_COLON");
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3804:8: lv_accessor_1_3= RULE_QUESTION_DOT
+ {
+ lv_accessor_1_3=(Token)match(input,RULE_QUESTION_DOT,FOLLOW_RULE_QUESTION_DOT_in_ruleProperty8123); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_1_3, grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_1_3,
+ "QUESTION_DOT");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3822:4: ( (lv_prop_2_0= ruleId ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3823:1: (lv_prop_2_0= ruleId )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3823:1: (lv_prop_2_0= ruleId )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3824:3: lv_prop_2_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleProperty8154);
+ lv_prop_2_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ current,
+ "prop",
+ lv_prop_2_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:6: ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:6: ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:7: ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:7: ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:8: ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:41: (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3842:5: this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_ruleProperty8195);
+ this_IdRef_3=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IdRef_3;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_INDEX_START_4=(Token)match(input,RULE_INDEX_START,FOLLOW_RULE_INDEX_START_in_ruleProperty8205); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDEX_START_4, grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3854:3: ( (lv_index_5_0= ruleIndex ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3855:1: (lv_index_5_0= ruleIndex )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3855:1: (lv_index_5_0= ruleIndex )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3856:3: lv_index_5_0= ruleIndex
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleIndex_in_ruleProperty8227);
+ lv_index_5_0=ruleIndex();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ current,
+ "index",
+ lv_index_5_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_INDEX_END_6=(Token)match(input,RULE_INDEX_END,FOLLOW_RULE_INDEX_END_in_ruleProperty8238); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDEX_END_6, grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleProperty"
+
+
+ // $ANTLR start "entryRuleVariable"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3884:1: entryRuleVariable returns [EObject current=null] : iv_ruleVariable= ruleVariable EOF ;
+ public final EObject entryRuleVariable() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleVariable = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3885:2: (iv_ruleVariable= ruleVariable EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3886:2: iv_ruleVariable= ruleVariable EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getVariableRule());
+ }
+ pushFollow(FOLLOW_ruleVariable_in_entryRuleVariable8274);
+ iv_ruleVariable=ruleVariable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleVariable;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleVariable8284); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleVariable"
+
+
+ // $ANTLR start "ruleVariable"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3893:1: ruleVariable returns [EObject current=null] : (this_Id_0= ruleId | ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* ) | this_Property_7= ruleProperty ) ;
+ public final EObject ruleVariable() throws RecognitionException {
+ EObject current = null;
+
+ Token this_AT_SIGIL_1=null;
+ Token this_THIS_2=null;
+ Token this_DOT_3=null;
+ Token this_DOT_5=null;
+ EObject this_Id_0 = null;
+
+ EObject this_Id_4 = null;
+
+ EObject lv_props_6_0 = null;
+
+ EObject this_Property_7 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3896:28: ( (this_Id_0= ruleId | ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* ) | this_Property_7= ruleProperty ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3897:1: (this_Id_0= ruleId | ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* ) | this_Property_7= ruleProperty )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3897:1: (this_Id_0= ruleId | ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* ) | this_Property_7= ruleProperty )
+ int alt71=3;
+ int LA71_0 = input.LA(1);
+
+ if ( (LA71_0==RULE_IDENTIFIER) ) {
+ int LA71_1 = input.LA(2);
+
+ if ( ((LA71_1>=RULE_DOT && LA71_1<=RULE_INDEX_START)) ) {
+ alt71=3;
+ }
+ else if ( (LA71_1==EOF||LA71_1==RULE_TERMINATOR||LA71_1==RULE_EQUAL||LA71_1==RULE_CALL_END||LA71_1==RULE_POST_IF||(LA71_1>=RULE_FOR && LA71_1<=RULE_UNTIL)||LA71_1==RULE_COMMA||LA71_1==RULE_BY||(LA71_1>=RULE_DOT_DOT && LA71_1<=RULE_MATH)||LA71_1==RULE_INDEX_END||LA71_1==RULE_RCURLY||LA71_1==RULE_PARAM_END||LA71_1==RULE_RPAREN) ) {
+ alt71=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 71, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA71_0==RULE_AT_SIGIL||LA71_0==RULE_THIS) ) {
+ alt71=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 71, 0, input);
+
+ throw nvae;
+ }
+ switch (alt71) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3898:5: this_Id_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getVariableAccess().getIdParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleVariable8331);
+ this_Id_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3907:6: ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3907:6: ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3907:7: (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )*
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3907:7: (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) )
+ int alt69=2;
+ int LA69_0 = input.LA(1);
+
+ if ( (LA69_0==RULE_AT_SIGIL) ) {
+ alt69=1;
+ }
+ else if ( (LA69_0==RULE_THIS) ) {
+ alt69=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 69, 0, input);
+
+ throw nvae;
+ }
+ switch (alt69) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3907:8: this_AT_SIGIL_1= RULE_AT_SIGIL
+ {
+ this_AT_SIGIL_1=(Token)match(input,RULE_AT_SIGIL,FOLLOW_RULE_AT_SIGIL_in_ruleVariable8349); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_AT_SIGIL_1, grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3912:6: (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3912:6: (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3912:7: this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT
+ {
+ this_THIS_2=(Token)match(input,RULE_THIS,FOLLOW_RULE_THIS_in_ruleVariable8366); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_THIS_2, grammarAccess.getVariableAccess().getTHISTerminalRuleCall_1_0_1_0());
+
+ }
+ this_DOT_3=(Token)match(input,RULE_DOT,FOLLOW_RULE_DOT_in_ruleVariable8376); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_DOT_3, grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_0_1_1());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getVariableAccess().getIdParserRuleCall_1_1());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleVariable8399);
+ this_Id_4=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_4;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3929:1: (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )*
+ loop70:
+ do {
+ int alt70=2;
+ int LA70_0 = input.LA(1);
+
+ if ( (LA70_0==RULE_DOT) ) {
+ alt70=1;
+ }
+
+
+ switch (alt70) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3929:2: this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) )
+ {
+ this_DOT_5=(Token)match(input,RULE_DOT,FOLLOW_RULE_DOT_in_ruleVariable8410); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_DOT_5, grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3933:1: ( (lv_props_6_0= ruleId ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3934:1: (lv_props_6_0= ruleId )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3934:1: (lv_props_6_0= ruleId )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3935:3: lv_props_6_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleVariable8430);
+ lv_props_6_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getVariableRule());
+ }
+ add(
+ current,
+ "props",
+ lv_props_6_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop70;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3953:5: this_Property_7= ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getVariableAccess().getPropertyParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleProperty_in_ruleVariable8461);
+ this_Property_7=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Property_7;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleVariable"
+
+
+ // $ANTLR start "entryRuleAssignableArray"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3969:1: entryRuleAssignableArray returns [EObject current=null] : iv_ruleAssignableArray= ruleAssignableArray EOF ;
+ public final EObject entryRuleAssignableArray() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignableArray = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3970:2: (iv_ruleAssignableArray= ruleAssignableArray EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3971:2: iv_ruleAssignableArray= ruleAssignableArray EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignableArrayRule());
+ }
+ pushFollow(FOLLOW_ruleAssignableArray_in_entryRuleAssignableArray8496);
+ iv_ruleAssignableArray=ruleAssignableArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignableArray;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignableArray8506); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignableArray"
+
+
+ // $ANTLR start "ruleAssignableArray"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3978:1: ruleAssignableArray returns [EObject current=null] : ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET ) ;
+ public final EObject ruleAssignableArray() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LBRACKET_0=null;
+ Token this_RBRACKET_2=null;
+ EObject this_AssignableArgList_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3981:28: ( ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3982:1: ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3982:1: ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3982:2: ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3982:2: ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3982:3: ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET
+ {
+ this_LBRACKET_0=(Token)match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_ruleAssignableArray8548); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LBRACKET_0, grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleAssignableArgList_in_ruleAssignableArray8570);
+ this_AssignableArgList_1=ruleAssignableArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_AssignableArgList_1;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_RBRACKET_2=(Token)match(input,RULE_RBRACKET,FOLLOW_RULE_RBRACKET_in_ruleAssignableArray8580); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RBRACKET_2, grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignableArray"
+
+
+ // $ANTLR start "entryRuleAssignableArgList"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4007:1: entryRuleAssignableArgList returns [EObject current=null] : iv_ruleAssignableArgList= ruleAssignableArgList EOF ;
+ public final EObject entryRuleAssignableArgList() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignableArgList = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4008:2: (iv_ruleAssignableArgList= ruleAssignableArgList EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4009:2: iv_ruleAssignableArgList= ruleAssignableArgList EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignableArgListRule());
+ }
+ pushFollow(FOLLOW_ruleAssignableArgList_in_entryRuleAssignableArgList8615);
+ iv_ruleAssignableArgList=ruleAssignableArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignableArgList;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignableArgList8625); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignableArgList"
+
+
+ // $ANTLR start "ruleAssignableArgList"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4016:1: ruleAssignableArgList returns [EObject current=null] : ( ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )* ) ;
+ public final EObject ruleAssignableArgList() throws RecognitionException {
+ EObject current = null;
+
+ Token this_COMMA_1=null;
+ EObject lv_args_0_0 = null;
+
+ EObject lv_args_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4019:28: ( ( ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4020:1: ( ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4020:1: ( ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4020:2: ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )*
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4020:2: ( (lv_args_0_0= ruleAssignableArg ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4021:1: (lv_args_0_0= ruleAssignableArg )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4021:1: (lv_args_0_0= ruleAssignableArg )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4022:3: lv_args_0_0= ruleAssignableArg
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignableArg_in_ruleAssignableArgList8671);
+ lv_args_0_0=ruleAssignableArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignableArgListRule());
+ }
+ add(
+ current,
+ "args",
+ lv_args_0_0,
+ "AssignableArg");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4038:2: (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )*
+ loop72:
+ do {
+ int alt72=2;
+ int LA72_0 = input.LA(1);
+
+ if ( (LA72_0==RULE_COMMA) ) {
+ alt72=1;
+ }
+
+
+ switch (alt72) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4038:3: this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) )
+ {
+ this_COMMA_1=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleAssignableArgList8683); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_1, grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4042:1: ( (lv_args_2_0= ruleAssignableArg ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4043:1: (lv_args_2_0= ruleAssignableArg )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4043:1: (lv_args_2_0= ruleAssignableArg )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4044:3: lv_args_2_0= ruleAssignableArg
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignableArg_in_ruleAssignableArgList8703);
+ lv_args_2_0=ruleAssignableArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignableArgListRule());
+ }
+ add(
+ current,
+ "args",
+ lv_args_2_0,
+ "AssignableArg");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop72;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignableArgList"
+
+
+ // $ANTLR start "entryRuleAssignableArg"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4068:1: entryRuleAssignableArg returns [EObject current=null] : iv_ruleAssignableArg= ruleAssignableArg EOF ;
+ public final EObject entryRuleAssignableArg() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignableArg = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4069:2: (iv_ruleAssignableArg= ruleAssignableArg EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4070:2: iv_ruleAssignableArg= ruleAssignableArg EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignableArgRule());
+ }
+ pushFollow(FOLLOW_ruleAssignableArg_in_entryRuleAssignableArg8741);
+ iv_ruleAssignableArg=ruleAssignableArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignableArg;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignableArg8751); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignableArg"
+
+
+ // $ANTLR start "ruleAssignableArg"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4077:1: ruleAssignableArg returns [EObject current=null] : ( ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? ) ;
+ public final EObject ruleAssignableArg() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_splat_1_0=null;
+ EObject lv_arg_0_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4080:28: ( ( ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4081:1: ( ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4081:1: ( ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4081:2: ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4081:2: ( (lv_arg_0_0= ruleAssignable ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4082:1: (lv_arg_0_0= ruleAssignable )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4082:1: (lv_arg_0_0= ruleAssignable )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4083:3: lv_arg_0_0= ruleAssignable
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignable_in_ruleAssignableArg8797);
+ lv_arg_0_0=ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignableArgRule());
+ }
+ set(
+ current,
+ "arg",
+ lv_arg_0_0,
+ "Assignable");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4099:2: ( (lv_splat_1_0= RULE_ELLIPSIS ) )?
+ int alt73=2;
+ int LA73_0 = input.LA(1);
+
+ if ( (LA73_0==RULE_ELLIPSIS) ) {
+ alt73=1;
+ }
+ switch (alt73) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4100:1: (lv_splat_1_0= RULE_ELLIPSIS )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4100:1: (lv_splat_1_0= RULE_ELLIPSIS )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4101:3: lv_splat_1_0= RULE_ELLIPSIS
+ {
+ lv_splat_1_0=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleAssignableArg8814); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_splat_1_0, grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAssignableArgRule());
+ }
+ setWithLastConsumed(
+ current,
+ "splat",
+ true,
+ "ELLIPSIS");
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignableArg"
+
+
+ // $ANTLR start "entryRuleAssignable"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4125:1: entryRuleAssignable returns [EObject current=null] : iv_ruleAssignable= ruleAssignable EOF ;
+ public final EObject entryRuleAssignable() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignable = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4126:2: (iv_ruleAssignable= ruleAssignable EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4127:2: iv_ruleAssignable= ruleAssignable EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignableRule());
+ }
+ pushFollow(FOLLOW_ruleAssignable_in_entryRuleAssignable8856);
+ iv_ruleAssignable=ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignable;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignable8866); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignable"
+
+
+ // $ANTLR start "ruleAssignable"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4134:1: ruleAssignable returns [EObject current=null] : (this_Variable_0= ruleVariable | ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary ) | ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray ) ) ;
+ public final EObject ruleAssignable() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Variable_0 = null;
+
+ EObject this_Dictionary_1 = null;
+
+ EObject this_AssignableArray_2 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4137:28: ( (this_Variable_0= ruleVariable | ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary ) | ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4138:1: (this_Variable_0= ruleVariable | ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary ) | ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4138:1: (this_Variable_0= ruleVariable | ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary ) | ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray ) )
+ int alt74=3;
+ int LA74_0 = input.LA(1);
+
+ if ( (LA74_0==RULE_AT_SIGIL||LA74_0==RULE_THIS||LA74_0==RULE_IDENTIFIER) ) {
+ alt74=1;
+ }
+ else if ( (LA74_0==RULE_LCURLY) && (synpred32_InternalCoffeeScript())) {
+ alt74=2;
+ }
+ else if ( (LA74_0==RULE_LBRACKET) && (synpred33_InternalCoffeeScript())) {
+ alt74=3;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 74, 0, input);
+
+ throw nvae;
+ }
+ switch (alt74) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4139:5: this_Variable_0= ruleVariable
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableAccess().getVariableParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleVariable_in_ruleAssignable8913);
+ this_Variable_0=ruleVariable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Variable_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4148:6: ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4148:6: ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4148:7: ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleDictionary_in_ruleAssignable8946);
+ this_Dictionary_1=ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Dictionary_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4158:6: ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4158:6: ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4158:7: ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleAssignableArray_in_ruleAssignable8980);
+ this_AssignableArray_2=ruleAssignableArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_AssignableArray_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignable"
+
+
+ // $ANTLR start "entryRuleArg"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4175:1: entryRuleArg returns [EObject current=null] : iv_ruleArg= ruleArg EOF ;
+ public final EObject entryRuleArg() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleArg = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4176:2: (iv_ruleArg= ruleArg EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4177:2: iv_ruleArg= ruleArg EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getArgRule());
+ }
+ pushFollow(FOLLOW_ruleArg_in_entryRuleArg9016);
+ iv_ruleArg=ruleArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleArg;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArg9026); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleArg"
+
+
+ // $ANTLR start "ruleArg"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4184:1: ruleArg returns [EObject current=null] : ( ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? ) ;
+ public final EObject ruleArg() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_splat_1_0=null;
+ EObject lv_exp_0_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4187:28: ( ( ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4188:1: ( ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4188:1: ( ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4188:2: ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4188:2: ( (lv_exp_0_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4189:1: (lv_exp_0_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4189:1: (lv_exp_0_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4190:3: lv_exp_0_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleArg9072);
+ lv_exp_0_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgRule());
+ }
+ set(
+ current,
+ "exp",
+ lv_exp_0_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4206:2: ( (lv_splat_1_0= RULE_ELLIPSIS ) )?
+ int alt75=2;
+ int LA75_0 = input.LA(1);
+
+ if ( (LA75_0==RULE_ELLIPSIS) ) {
+ alt75=1;
+ }
+ switch (alt75) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4207:1: (lv_splat_1_0= RULE_ELLIPSIS )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4207:1: (lv_splat_1_0= RULE_ELLIPSIS )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4208:3: lv_splat_1_0= RULE_ELLIPSIS
+ {
+ lv_splat_1_0=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleArg9089); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_splat_1_0, grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getArgRule());
+ }
+ setWithLastConsumed(
+ current,
+ "splat",
+ true,
+ "ELLIPSIS");
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleArg"
+
+
+ // $ANTLR start "entryRuleArgLine"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4232:1: entryRuleArgLine returns [EObject current=null] : iv_ruleArgLine= ruleArgLine EOF ;
+ public final EObject entryRuleArgLine() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleArgLine = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4233:2: (iv_ruleArgLine= ruleArgLine EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4234:2: iv_ruleArgLine= ruleArgLine EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getArgLineRule());
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_entryRuleArgLine9131);
+ iv_ruleArgLine=ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleArgLine;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArgLine9141); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleArgLine"
+
+
+ // $ANTLR start "ruleArgLine"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4241:1: ruleArgLine returns [EObject current=null] : ( ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )? ) ;
+ public final EObject ruleArgLine() throws RecognitionException {
+ EObject current = null;
+
+ Token this_COMMA_1=null;
+ Token this_COMMA_3=null;
+ EObject lv_head_0_0 = null;
+
+ EObject lv_tail_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4244:28: ( ( ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4245:1: ( ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4245:1: ( ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4245:2: ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4245:2: ( (lv_head_0_0= ruleArg ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4246:1: (lv_head_0_0= ruleArg )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4246:1: (lv_head_0_0= ruleArg )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4247:3: lv_head_0_0= ruleArg
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleArg_in_ruleArgLine9187);
+ lv_head_0_0=ruleArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgLineRule());
+ }
+ set(
+ current,
+ "head",
+ lv_head_0_0,
+ "Arg");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4263:2: (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )*
+ loop76:
+ do {
+ int alt76=2;
+ int LA76_0 = input.LA(1);
+
+ if ( (LA76_0==RULE_COMMA) ) {
+ int LA76_1 = input.LA(2);
+
+ if ( (LA76_1==RULE_STRING||(LA76_1>=RULE_FOR && LA76_1<=RULE_WHILE)||LA76_1==RULE_UNTIL||LA76_1==RULE_LBRACKET||(LA76_1>=RULE_PLUS && LA76_1<=RULE_MINUS)||(LA76_1>=RULE_UNARY && LA76_1<=RULE_MINUS_MINUS)||LA76_1==RULE_SUPER||LA76_1==RULE_AT_SIGIL||(LA76_1>=RULE_THIS && LA76_1<=RULE_TRY)||LA76_1==RULE_SWITCH||(LA76_1>=RULE_IF && LA76_1<=RULE_LCURLY)||LA76_1==RULE_PARAM_START||(LA76_1>=RULE_FUNC_ARROW && LA76_1<=RULE_LPAREN)) ) {
+ alt76=1;
+ }
+
+
+ }
+
+
+ switch (alt76) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4263:3: this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) )
+ {
+ this_COMMA_1=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleArgLine9199); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_1, grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4267:1: ( (lv_tail_2_0= ruleArg ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4268:1: (lv_tail_2_0= ruleArg )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4268:1: (lv_tail_2_0= ruleArg )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4269:3: lv_tail_2_0= ruleArg
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleArg_in_ruleArgLine9219);
+ lv_tail_2_0=ruleArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgLineRule());
+ }
+ add(
+ current,
+ "tail",
+ lv_tail_2_0,
+ "Arg");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop76;
+ }
+ } while (true);
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4285:4: (this_COMMA_3= RULE_COMMA )?
+ int alt77=2;
+ int LA77_0 = input.LA(1);
+
+ if ( (LA77_0==RULE_COMMA) ) {
+ alt77=1;
+ }
+ switch (alt77) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4285:5: this_COMMA_3= RULE_COMMA
+ {
+ this_COMMA_3=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleArgLine9233); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_3, grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleArgLine"
+
+
+ // $ANTLR start "entryRuleExplicitArgList"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4297:1: entryRuleExplicitArgList returns [EObject current=null] : iv_ruleExplicitArgList= ruleExplicitArgList EOF ;
+ public final EObject entryRuleExplicitArgList() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleExplicitArgList = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4298:2: (iv_ruleExplicitArgList= ruleExplicitArgList EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4299:2: iv_ruleExplicitArgList= ruleExplicitArgList EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getExplicitArgListRule());
+ }
+ pushFollow(FOLLOW_ruleExplicitArgList_in_entryRuleExplicitArgList9270);
+ iv_ruleExplicitArgList=ruleExplicitArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleExplicitArgList;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExplicitArgList9280); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleExplicitArgList"
+
+
+ // $ANTLR start "ruleExplicitArgList"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4306:1: ruleExplicitArgList returns [EObject current=null] : ( ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* ) ;
+ public final EObject ruleExplicitArgList() throws RecognitionException {
+ EObject current = null;
+
+ Token this_TERMINATOR_1=null;
+ Token this_INDENT_3=null;
+ Token this_OUTDENT_5=null;
+ EObject lv_lines_0_0 = null;
+
+ EObject lv_lines_2_0 = null;
+
+ EObject lv_lines_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4309:28: ( ( ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4310:1: ( ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4310:1: ( ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4310:2: ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )*
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4310:2: ( (lv_lines_0_0= ruleArgLine ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4311:1: (lv_lines_0_0= ruleArgLine )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4311:1: (lv_lines_0_0= ruleArgLine )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4312:3: lv_lines_0_0= ruleArgLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_ruleExplicitArgList9326);
+ lv_lines_0_0=ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_0_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4328:2: ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )*
+ loop78:
+ do {
+ int alt78=3;
+ int LA78_0 = input.LA(1);
+
+ if ( (LA78_0==RULE_TERMINATOR) ) {
+ alt78=1;
+ }
+ else if ( (LA78_0==RULE_INDENT) ) {
+ alt78=2;
+ }
+
+
+ switch (alt78) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4328:3: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4328:3: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4328:4: this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) )
+ {
+ this_TERMINATOR_1=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleExplicitArgList9339); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4332:1: ( (lv_lines_2_0= ruleArgLine ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4333:1: (lv_lines_2_0= ruleArgLine )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4333:1: (lv_lines_2_0= ruleArgLine )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4334:3: lv_lines_2_0= ruleArgLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_ruleExplicitArgList9359);
+ lv_lines_2_0=ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_2_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4351:6: (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4351:6: (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4351:7: this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT
+ {
+ this_INDENT_3=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleExplicitArgList9378); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_3, grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4355:1: ( (lv_lines_4_0= ruleArgLine ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4356:1: (lv_lines_4_0= ruleArgLine )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4356:1: (lv_lines_4_0= ruleArgLine )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4357:3: lv_lines_4_0= ruleArgLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_ruleExplicitArgList9398);
+ lv_lines_4_0=ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_4_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_5=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleExplicitArgList9409); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_5, grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop78;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleExplicitArgList"
+
+
+ // $ANTLR start "entryRuleArgList"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4385:1: entryRuleArgList returns [EObject current=null] : iv_ruleArgList= ruleArgList EOF ;
+ public final EObject entryRuleArgList() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleArgList = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4386:2: (iv_ruleArgList= ruleArgList EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4387:2: iv_ruleArgList= ruleArgList EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getArgListRule());
+ }
+ pushFollow(FOLLOW_ruleArgList_in_entryRuleArgList9447);
+ iv_ruleArgList=ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleArgList;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArgList9457); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleArgList"
+
+
+ // $ANTLR start "ruleArgList"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4394:1: ruleArgList returns [EObject current=null] : ( () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )? ) ;
+ public final EObject ruleArgList() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDENT_2=null;
+ Token this_OUTDENT_4=null;
+ EObject lv_dummy_1_0 = null;
+
+ EObject lv_dummy_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4397:28: ( ( () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4398:1: ( () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4398:1: ( () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4398:2: () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4398:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4399:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getArgListAccess().getArgListAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4404:2: ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )?
+ int alt79=3;
+ int LA79_0 = input.LA(1);
+
+ if ( (LA79_0==RULE_STRING||(LA79_0>=RULE_FOR && LA79_0<=RULE_WHILE)||LA79_0==RULE_UNTIL||LA79_0==RULE_LBRACKET||(LA79_0>=RULE_PLUS && LA79_0<=RULE_MINUS)||(LA79_0>=RULE_UNARY && LA79_0<=RULE_MINUS_MINUS)||LA79_0==RULE_SUPER||LA79_0==RULE_AT_SIGIL||(LA79_0>=RULE_THIS && LA79_0<=RULE_TRY)||LA79_0==RULE_SWITCH||(LA79_0>=RULE_IF && LA79_0<=RULE_LCURLY)||LA79_0==RULE_PARAM_START||(LA79_0>=RULE_FUNC_ARROW && LA79_0<=RULE_LPAREN)) ) {
+ alt79=1;
+ }
+ else if ( (LA79_0==RULE_INDENT) ) {
+ alt79=2;
+ }
+ switch (alt79) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4404:3: ( (lv_dummy_1_0= ruleExplicitArgList ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4404:3: ( (lv_dummy_1_0= ruleExplicitArgList ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4405:1: (lv_dummy_1_0= ruleExplicitArgList )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4405:1: (lv_dummy_1_0= ruleExplicitArgList )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4406:3: lv_dummy_1_0= ruleExplicitArgList
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExplicitArgList_in_ruleArgList9513);
+ lv_dummy_1_0=ruleExplicitArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgListRule());
+ }
+ set(
+ current,
+ "dummy",
+ lv_dummy_1_0,
+ "ExplicitArgList");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4423:6: (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4423:6: (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4423:7: this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT
+ {
+ this_INDENT_2=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleArgList9531); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_2, grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4427:1: ( (lv_dummy_3_0= ruleExplicitArgList ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4428:1: (lv_dummy_3_0= ruleExplicitArgList )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4428:1: (lv_dummy_3_0= ruleExplicitArgList )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4429:3: lv_dummy_3_0= ruleExplicitArgList
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExplicitArgList_in_ruleArgList9551);
+ lv_dummy_3_0=ruleExplicitArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgListRule());
+ }
+ set(
+ current,
+ "dummy",
+ lv_dummy_3_0,
+ "ExplicitArgList");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_4=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleArgList9562); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_4, grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleArgList"
+
+
+ // $ANTLR start "entryRuleArray"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4457:1: entryRuleArray returns [EObject current=null] : iv_ruleArray= ruleArray EOF ;
+ public final EObject entryRuleArray() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleArray = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4458:2: (iv_ruleArray= ruleArray EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4459:2: iv_ruleArray= ruleArray EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getArrayRule());
+ }
+ pushFollow(FOLLOW_ruleArray_in_entryRuleArray9600);
+ iv_ruleArray=ruleArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleArray;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArray9610); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleArray"
+
+
+ // $ANTLR start "ruleArray"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4466:1: ruleArray returns [EObject current=null] : ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET ) ;
+ public final EObject ruleArray() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LBRACKET_0=null;
+ Token this_RBRACKET_2=null;
+ EObject this_ArgList_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4469:28: ( ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4470:1: ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4470:1: ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4470:2: ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4470:2: ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4470:3: ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET
+ {
+ this_LBRACKET_0=(Token)match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_ruleArray9652); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LBRACKET_0, grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArrayAccess().getArgListParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleArgList_in_ruleArray9674);
+ this_ArgList_1=ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ArgList_1;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_RBRACKET_2=(Token)match(input,RULE_RBRACKET,FOLLOW_RULE_RBRACKET_in_ruleArray9684); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RBRACKET_2, grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleArray"
+
+
+ // $ANTLR start "entryRuleDictionary"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4495:1: entryRuleDictionary returns [EObject current=null] : iv_ruleDictionary= ruleDictionary EOF ;
+ public final EObject entryRuleDictionary() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictionary = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4496:2: (iv_ruleDictionary= ruleDictionary EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4497:2: iv_ruleDictionary= ruleDictionary EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictionaryRule());
+ }
+ pushFollow(FOLLOW_ruleDictionary_in_entryRuleDictionary9719);
+ iv_ruleDictionary=ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictionary;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictionary9729); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictionary"
+
+
+ // $ANTLR start "ruleDictionary"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4504:1: ruleDictionary returns [EObject current=null] : ( ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY ) ;
+ public final EObject ruleDictionary() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LCURLY_0=null;
+ Token this_RCURLY_2=null;
+ EObject this_DictItems_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4507:28: ( ( ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4508:1: ( ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4508:1: ( ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4508:2: ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4508:2: ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4508:3: ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY
+ {
+ this_LCURLY_0=(Token)match(input,RULE_LCURLY,FOLLOW_RULE_LCURLY_in_ruleDictionary9771); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LCURLY_0, grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleDictItems_in_ruleDictionary9793);
+ this_DictItems_1=ruleDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_DictItems_1;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_RCURLY_2=(Token)match(input,RULE_RCURLY,FOLLOW_RULE_RCURLY_in_ruleDictionary9803); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RCURLY_2, grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictionary"
+
+
+ // $ANTLR start "entryRuleDictItems"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4533:1: entryRuleDictItems returns [EObject current=null] : iv_ruleDictItems= ruleDictItems EOF ;
+ public final EObject entryRuleDictItems() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictItems = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4534:2: (iv_ruleDictItems= ruleDictItems EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4535:2: iv_ruleDictItems= ruleDictItems EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictItemsRule());
+ }
+ pushFollow(FOLLOW_ruleDictItems_in_entryRuleDictItems9838);
+ iv_ruleDictItems=ruleDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictItems;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictItems9848); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictItems"
+
+
+ // $ANTLR start "ruleDictItems"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4542:1: ruleDictItems returns [EObject current=null] : ( () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )? ) ;
+ public final EObject ruleDictItems() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDENT_2=null;
+ Token this_OUTDENT_4=null;
+ EObject lv_dummy_1_0 = null;
+
+ EObject lv_dummy_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4545:28: ( ( () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4546:1: ( () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4546:1: ( () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4546:2: () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4546:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4547:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getDictItemsAccess().getDictItemsAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4552:2: ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )?
+ int alt80=3;
+ int LA80_0 = input.LA(1);
+
+ if ( (LA80_0==RULE_STRING||LA80_0==RULE_IDENTIFIER||(LA80_0>=RULE_NUMBER && LA80_0<=RULE_REGEX)) ) {
+ alt80=1;
+ }
+ else if ( (LA80_0==RULE_INDENT) ) {
+ alt80=2;
+ }
+ switch (alt80) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4552:3: ( (lv_dummy_1_0= ruleExplicitDictItems ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4552:3: ( (lv_dummy_1_0= ruleExplicitDictItems ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4553:1: (lv_dummy_1_0= ruleExplicitDictItems )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4553:1: (lv_dummy_1_0= ruleExplicitDictItems )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4554:3: lv_dummy_1_0= ruleExplicitDictItems
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExplicitDictItems_in_ruleDictItems9904);
+ lv_dummy_1_0=ruleExplicitDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemsRule());
+ }
+ set(
+ current,
+ "dummy",
+ lv_dummy_1_0,
+ "ExplicitDictItems");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4571:6: (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4571:6: (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4571:7: this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT
+ {
+ this_INDENT_2=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleDictItems9922); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_2, grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4575:1: ( (lv_dummy_3_0= ruleExplicitDictItems ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4576:1: (lv_dummy_3_0= ruleExplicitDictItems )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4576:1: (lv_dummy_3_0= ruleExplicitDictItems )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4577:3: lv_dummy_3_0= ruleExplicitDictItems
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExplicitDictItems_in_ruleDictItems9942);
+ lv_dummy_3_0=ruleExplicitDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemsRule());
+ }
+ set(
+ current,
+ "dummy",
+ lv_dummy_3_0,
+ "ExplicitDictItems");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_4=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleDictItems9953); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_4, grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictItems"
+
+
+ // $ANTLR start "entryRuleExplicitDictItems"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4605:1: entryRuleExplicitDictItems returns [EObject current=null] : iv_ruleExplicitDictItems= ruleExplicitDictItems EOF ;
+ public final EObject entryRuleExplicitDictItems() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleExplicitDictItems = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4606:2: (iv_ruleExplicitDictItems= ruleExplicitDictItems EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4607:2: iv_ruleExplicitDictItems= ruleExplicitDictItems EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getExplicitDictItemsRule());
+ }
+ pushFollow(FOLLOW_ruleExplicitDictItems_in_entryRuleExplicitDictItems9991);
+ iv_ruleExplicitDictItems=ruleExplicitDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleExplicitDictItems;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExplicitDictItems10001); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleExplicitDictItems"
+
+
+ // $ANTLR start "ruleExplicitDictItems"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4614:1: ruleExplicitDictItems returns [EObject current=null] : ( ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* ) ;
+ public final EObject ruleExplicitDictItems() throws RecognitionException {
+ EObject current = null;
+
+ Token this_TERMINATOR_1=null;
+ Token this_INDENT_3=null;
+ Token this_OUTDENT_5=null;
+ EObject lv_lines_0_0 = null;
+
+ EObject lv_lines_2_0 = null;
+
+ EObject lv_lines_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4617:28: ( ( ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4618:1: ( ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4618:1: ( ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4618:2: ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )*
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4618:2: ( (lv_lines_0_0= ruleDictLine ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4619:1: (lv_lines_0_0= ruleDictLine )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4619:1: (lv_lines_0_0= ruleDictLine )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4620:3: lv_lines_0_0= ruleDictLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_ruleExplicitDictItems10047);
+ lv_lines_0_0=ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_0_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4636:2: ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )*
+ loop81:
+ do {
+ int alt81=3;
+ int LA81_0 = input.LA(1);
+
+ if ( (LA81_0==RULE_TERMINATOR) ) {
+ alt81=1;
+ }
+ else if ( (LA81_0==RULE_INDENT) ) {
+ alt81=2;
+ }
+
+
+ switch (alt81) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4636:3: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4636:3: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4636:4: this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) )
+ {
+ this_TERMINATOR_1=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleExplicitDictItems10060); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4640:1: ( (lv_lines_2_0= ruleDictLine ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4641:1: (lv_lines_2_0= ruleDictLine )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4641:1: (lv_lines_2_0= ruleDictLine )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4642:3: lv_lines_2_0= ruleDictLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_ruleExplicitDictItems10080);
+ lv_lines_2_0=ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_2_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4659:6: (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4659:6: (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4659:7: this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT
+ {
+ this_INDENT_3=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleExplicitDictItems10099); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_3, grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4663:1: ( (lv_lines_4_0= ruleDictLine ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4664:1: (lv_lines_4_0= ruleDictLine )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4664:1: (lv_lines_4_0= ruleDictLine )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4665:3: lv_lines_4_0= ruleDictLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_ruleExplicitDictItems10119);
+ lv_lines_4_0=ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_4_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_5=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleExplicitDictItems10130); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_5, grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop81;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleExplicitDictItems"
+
+
+ // $ANTLR start "entryRuleDictLine"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4693:1: entryRuleDictLine returns [EObject current=null] : iv_ruleDictLine= ruleDictLine EOF ;
+ public final EObject entryRuleDictLine() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictLine = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4694:2: (iv_ruleDictLine= ruleDictLine EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4695:2: iv_ruleDictLine= ruleDictLine EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictLineRule());
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_entryRuleDictLine10168);
+ iv_ruleDictLine=ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictLine;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictLine10178); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictLine"
+
+
+ // $ANTLR start "ruleDictLine"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4702:1: ruleDictLine returns [EObject current=null] : ( ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )? ) ;
+ public final EObject ruleDictLine() throws RecognitionException {
+ EObject current = null;
+
+ Token this_COMMA_1=null;
+ Token this_COMMA_3=null;
+ EObject lv_head_0_0 = null;
+
+ EObject lv_tail_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4705:28: ( ( ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4706:1: ( ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4706:1: ( ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4706:2: ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4706:2: ( (lv_head_0_0= ruleDictItem ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4707:1: (lv_head_0_0= ruleDictItem )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4707:1: (lv_head_0_0= ruleDictItem )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4708:3: lv_head_0_0= ruleDictItem
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictItem_in_ruleDictLine10224);
+ lv_head_0_0=ruleDictItem();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictLineRule());
+ }
+ set(
+ current,
+ "head",
+ lv_head_0_0,
+ "DictItem");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4724:2: (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )*
+ loop82:
+ do {
+ int alt82=2;
+ int LA82_0 = input.LA(1);
+
+ if ( (LA82_0==RULE_COMMA) ) {
+ int LA82_1 = input.LA(2);
+
+ if ( (LA82_1==RULE_STRING||LA82_1==RULE_IDENTIFIER||(LA82_1>=RULE_NUMBER && LA82_1<=RULE_REGEX)) ) {
+ alt82=1;
+ }
+
+
+ }
+
+
+ switch (alt82) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4724:3: this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) )
+ {
+ this_COMMA_1=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleDictLine10236); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_1, grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4728:1: ( (lv_tail_2_0= ruleDictItem ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4729:1: (lv_tail_2_0= ruleDictItem )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4729:1: (lv_tail_2_0= ruleDictItem )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4730:3: lv_tail_2_0= ruleDictItem
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictItem_in_ruleDictLine10256);
+ lv_tail_2_0=ruleDictItem();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictLineRule());
+ }
+ add(
+ current,
+ "tail",
+ lv_tail_2_0,
+ "DictItem");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop82;
+ }
+ } while (true);
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4746:4: (this_COMMA_3= RULE_COMMA )?
+ int alt83=2;
+ int LA83_0 = input.LA(1);
+
+ if ( (LA83_0==RULE_COMMA) ) {
+ alt83=1;
+ }
+ switch (alt83) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4746:5: this_COMMA_3= RULE_COMMA
+ {
+ this_COMMA_3=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleDictLine10270); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_3, grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictLine"
+
+
+ // $ANTLR start "entryRuleDictItem"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4758:1: entryRuleDictItem returns [EObject current=null] : iv_ruleDictItem= ruleDictItem EOF ;
+ public final EObject entryRuleDictItem() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictItem = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4759:2: (iv_ruleDictItem= ruleDictItem EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4760:2: iv_ruleDictItem= ruleDictItem EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictItemRule());
+ }
+ pushFollow(FOLLOW_ruleDictItem_in_entryRuleDictItem10307);
+ iv_ruleDictItem=ruleDictItem();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictItem;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictItem10317); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictItem"
+
+
+ // $ANTLR start "ruleDictItem"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4767:1: ruleDictItem returns [EObject current=null] : ( () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )? ) ;
+ public final EObject ruleDictItem() throws RecognitionException {
+ EObject current = null;
+
+ Token this_COLON_2=null;
+ Token this_INDENT_4=null;
+ Token this_OUTDENT_6=null;
+ EObject lv_key_1_0 = null;
+
+ EObject lv_value_3_0 = null;
+
+ EObject lv_value_5_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4770:28: ( ( () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4771:1: ( () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4771:1: ( () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4771:2: () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4771:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4772:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getDictItemAccess().getDictItemAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4777:2: ( (lv_key_1_0= ruleDictKey ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4778:1: (lv_key_1_0= ruleDictKey )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4778:1: (lv_key_1_0= ruleDictKey )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4779:3: lv_key_1_0= ruleDictKey
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictKey_in_ruleDictItem10372);
+ lv_key_1_0=ruleDictKey();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ current,
+ "key",
+ lv_key_1_0,
+ "DictKey");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4795:2: (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )?
+ int alt85=2;
+ int LA85_0 = input.LA(1);
+
+ if ( (LA85_0==RULE_COLON) ) {
+ alt85=1;
+ }
+ switch (alt85) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4795:3: this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) )
+ {
+ this_COLON_2=(Token)match(input,RULE_COLON,FOLLOW_RULE_COLON_in_ruleDictItem10384); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COLON_2, grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4799:1: ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) )
+ int alt84=2;
+ int LA84_0 = input.LA(1);
+
+ if ( (LA84_0==RULE_STRING||(LA84_0>=RULE_FOR && LA84_0<=RULE_WHILE)||LA84_0==RULE_UNTIL||LA84_0==RULE_LBRACKET||(LA84_0>=RULE_PLUS && LA84_0<=RULE_MINUS)||(LA84_0>=RULE_UNARY && LA84_0<=RULE_MINUS_MINUS)||LA84_0==RULE_SUPER||LA84_0==RULE_AT_SIGIL||(LA84_0>=RULE_THIS && LA84_0<=RULE_TRY)||LA84_0==RULE_SWITCH||(LA84_0>=RULE_IF && LA84_0<=RULE_LCURLY)||LA84_0==RULE_PARAM_START||(LA84_0>=RULE_FUNC_ARROW && LA84_0<=RULE_LPAREN)) ) {
+ alt84=1;
+ }
+ else if ( (LA84_0==RULE_INDENT) ) {
+ alt84=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 84, 0, input);
+
+ throw nvae;
+ }
+ switch (alt84) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4799:2: ( (lv_value_3_0= ruleExpression ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4799:2: ( (lv_value_3_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4800:1: (lv_value_3_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4800:1: (lv_value_3_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4801:3: lv_value_3_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleDictItem10405);
+ lv_value_3_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4818:6: (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4818:6: (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4818:7: this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT
+ {
+ this_INDENT_4=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleDictItem10423); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_4, grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4822:1: ( (lv_value_5_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4823:1: (lv_value_5_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4823:1: (lv_value_5_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4824:3: lv_value_5_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleDictItem10443);
+ lv_value_5_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_5_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_6=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleDictItem10454); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_6, grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictItem"
+
+
+ // $ANTLR start "entryRuleDictKey"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4852:1: entryRuleDictKey returns [EObject current=null] : iv_ruleDictKey= ruleDictKey EOF ;
+ public final EObject entryRuleDictKey() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictKey = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4853:2: (iv_ruleDictKey= ruleDictKey EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4854:2: iv_ruleDictKey= ruleDictKey EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictKeyRule());
+ }
+ pushFollow(FOLLOW_ruleDictKey_in_entryRuleDictKey10493);
+ iv_ruleDictKey=ruleDictKey();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictKey;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictKey10503); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictKey"
+
+
+ // $ANTLR start "ruleDictKey"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4861:1: ruleDictKey returns [EObject current=null] : (this_Literal_0= ruleLiteral | this_Id_1= ruleId ) ;
+ public final EObject ruleDictKey() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Literal_0 = null;
+
+ EObject this_Id_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4864:28: ( (this_Literal_0= ruleLiteral | this_Id_1= ruleId ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4865:1: (this_Literal_0= ruleLiteral | this_Id_1= ruleId )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4865:1: (this_Literal_0= ruleLiteral | this_Id_1= ruleId )
+ int alt86=2;
+ int LA86_0 = input.LA(1);
+
+ if ( (LA86_0==RULE_STRING||(LA86_0>=RULE_NUMBER && LA86_0<=RULE_REGEX)) ) {
+ alt86=1;
+ }
+ else if ( (LA86_0==RULE_IDENTIFIER) ) {
+ alt86=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 86, 0, input);
+
+ throw nvae;
+ }
+ switch (alt86) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4866:5: this_Literal_0= ruleLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleLiteral_in_ruleDictKey10550);
+ this_Literal_0=ruleLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Literal_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4876:5: this_Id_1= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictKeyAccess().getIdParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleDictKey10577);
+ this_Id_1=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictKey"
+
+
+ // $ANTLR start "entryRuleLambda"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4892:1: entryRuleLambda returns [EObject current=null] : iv_ruleLambda= ruleLambda EOF ;
+ public final EObject entryRuleLambda() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleLambda = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4893:2: (iv_ruleLambda= ruleLambda EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4894:2: iv_ruleLambda= ruleLambda EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getLambdaRule());
+ }
+ pushFollow(FOLLOW_ruleLambda_in_entryRuleLambda10612);
+ iv_ruleLambda=ruleLambda();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleLambda;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLambda10622); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleLambda"
+
+
+ // $ANTLR start "ruleLambda"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4901:1: ruleLambda returns [EObject current=null] : ( (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) ) ) ;
+ public final EObject ruleLambda() throws RecognitionException {
+ EObject current = null;
+
+ Token this_PARAM_START_0=null;
+ Token this_COMMA_2=null;
+ Token this_PARAM_END_4=null;
+ Token this_FUNC_ARROW_5=null;
+ Token this_BOUND_FUNC_ARROW_6=null;
+ EObject lv_params_1_0 = null;
+
+ EObject lv_params_3_0 = null;
+
+ EObject lv_body_7_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4904:28: ( ( (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4905:1: ( (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4905:1: ( (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4905:2: (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4905:2: (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )?
+ int alt89=2;
+ int LA89_0 = input.LA(1);
+
+ if ( (LA89_0==RULE_PARAM_START) ) {
+ alt89=1;
+ }
+ switch (alt89) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4905:3: this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END
+ {
+ this_PARAM_START_0=(Token)match(input,RULE_PARAM_START,FOLLOW_RULE_PARAM_START_in_ruleLambda10659); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PARAM_START_0, grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4909:1: ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )?
+ int alt88=2;
+ int LA88_0 = input.LA(1);
+
+ if ( (LA88_0==RULE_LBRACKET||LA88_0==RULE_AT_SIGIL||(LA88_0>=RULE_IDENTIFIER && LA88_0<=RULE_LCURLY)) ) {
+ alt88=1;
+ }
+ switch (alt88) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4909:2: ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )*
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4909:2: ( (lv_params_1_0= ruleParam ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4910:1: (lv_params_1_0= ruleParam )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4910:1: (lv_params_1_0= ruleParam )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4911:3: lv_params_1_0= ruleParam
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleParam_in_ruleLambda10680);
+ lv_params_1_0=ruleParam();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ add(
+ current,
+ "params",
+ lv_params_1_0,
+ "Param");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4927:2: (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )*
+ loop87:
+ do {
+ int alt87=2;
+ int LA87_0 = input.LA(1);
+
+ if ( (LA87_0==RULE_COMMA) ) {
+ alt87=1;
+ }
+
+
+ switch (alt87) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4927:3: this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) )
+ {
+ this_COMMA_2=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleLambda10692); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_2, grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4931:1: ( (lv_params_3_0= ruleParam ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4932:1: (lv_params_3_0= ruleParam )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4932:1: (lv_params_3_0= ruleParam )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4933:3: lv_params_3_0= ruleParam
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleParam_in_ruleLambda10712);
+ lv_params_3_0=ruleParam();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ add(
+ current,
+ "params",
+ lv_params_3_0,
+ "Param");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop87;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ this_PARAM_END_4=(Token)match(input,RULE_PARAM_END,FOLLOW_RULE_PARAM_END_in_ruleLambda10727); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PARAM_END_4, grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4953:3: (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW )
+ int alt90=2;
+ int LA90_0 = input.LA(1);
+
+ if ( (LA90_0==RULE_FUNC_ARROW) ) {
+ alt90=1;
+ }
+ else if ( (LA90_0==RULE_BOUND_FUNC_ARROW) ) {
+ alt90=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 90, 0, input);
+
+ throw nvae;
+ }
+ switch (alt90) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4953:4: this_FUNC_ARROW_5= RULE_FUNC_ARROW
+ {
+ this_FUNC_ARROW_5=(Token)match(input,RULE_FUNC_ARROW,FOLLOW_RULE_FUNC_ARROW_in_ruleLambda10740); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FUNC_ARROW_5, grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4958:6: this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW
+ {
+ this_BOUND_FUNC_ARROW_6=(Token)match(input,RULE_BOUND_FUNC_ARROW,FOLLOW_RULE_BOUND_FUNC_ARROW_in_ruleLambda10756); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_BOUND_FUNC_ARROW_6, grammarAccess.getLambdaAccess().getBOUND_FUNC_ARROWTerminalRuleCall_1_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4962:2: ( (lv_body_7_0= ruleBlock ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4963:1: (lv_body_7_0= ruleBlock )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4963:1: (lv_body_7_0= ruleBlock )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4964:3: lv_body_7_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleLambda10777);
+ lv_body_7_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_7_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleLambda"
+
+
+ // $ANTLR start "entryRuleParam"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4988:1: entryRuleParam returns [EObject current=null] : iv_ruleParam= ruleParam EOF ;
+ public final EObject entryRuleParam() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleParam = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4989:2: (iv_ruleParam= ruleParam EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4990:2: iv_ruleParam= ruleParam EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getParamRule());
+ }
+ pushFollow(FOLLOW_ruleParam_in_entryRuleParam10813);
+ iv_ruleParam=ruleParam();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleParam;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleParam10823); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleParam"
+
+
+ // $ANTLR start "ruleParam"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4997:1: ruleParam returns [EObject current=null] : ( (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )? ) ;
+ public final EObject ruleParam() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_splat_4_0=null;
+ Token this_EQUAL_5=null;
+ EObject this_Id_0 = null;
+
+ EObject this_Array_1 = null;
+
+ EObject this_Dictionary_2 = null;
+
+ EObject this_ThisProperty_3 = null;
+
+ EObject lv_defaultValue_6_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5000:28: ( ( (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )? ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5001:1: ( (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )? )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5001:1: ( (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )? )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5001:2: (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )?
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5001:2: (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty )
+ int alt91=4;
+ int LA91_0 = input.LA(1);
+
+ if ( (LA91_0==RULE_IDENTIFIER) ) {
+ alt91=1;
+ }
+ else if ( (LA91_0==RULE_LBRACKET) && (synpred36_InternalCoffeeScript())) {
+ alt91=2;
+ }
+ else if ( (LA91_0==RULE_LCURLY) && (synpred37_InternalCoffeeScript())) {
+ alt91=3;
+ }
+ else if ( (LA91_0==RULE_AT_SIGIL) ) {
+ alt91=4;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 91, 0, input);
+
+ throw nvae;
+ }
+ switch (alt91) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5002:5: this_Id_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getIdParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleParam10871);
+ this_Id_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5011:6: ( ( RULE_LBRACKET )=>this_Array_1= ruleArray )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5011:6: ( ( RULE_LBRACKET )=>this_Array_1= ruleArray )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5011:7: ( RULE_LBRACKET )=>this_Array_1= ruleArray
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getArrayParserRuleCall_0_1());
+
+ }
+ pushFollow(FOLLOW_ruleArray_in_ruleParam10904);
+ this_Array_1=ruleArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Array_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5021:6: ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5021:6: ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5021:7: ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2());
+
+ }
+ pushFollow(FOLLOW_ruleDictionary_in_ruleParam10938);
+ this_Dictionary_2=ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Dictionary_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5032:5: this_ThisProperty_3= ruleThisProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3());
+
+ }
+ pushFollow(FOLLOW_ruleThisProperty_in_ruleParam10966);
+ this_ThisProperty_3=ruleThisProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ThisProperty_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5040:2: ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )?
+ int alt92=3;
+ int LA92_0 = input.LA(1);
+
+ if ( (LA92_0==RULE_ELLIPSIS) ) {
+ alt92=1;
+ }
+ else if ( (LA92_0==RULE_EQUAL) ) {
+ alt92=2;
+ }
+ switch (alt92) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5040:3: ( (lv_splat_4_0= RULE_ELLIPSIS ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5040:3: ( (lv_splat_4_0= RULE_ELLIPSIS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5041:1: (lv_splat_4_0= RULE_ELLIPSIS )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5041:1: (lv_splat_4_0= RULE_ELLIPSIS )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5042:3: lv_splat_4_0= RULE_ELLIPSIS
+ {
+ lv_splat_4_0=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleParam10984); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_splat_4_0, grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getParamRule());
+ }
+ setWithLastConsumed(
+ current,
+ "splat",
+ true,
+ "ELLIPSIS");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5059:6: (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5059:6: (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5059:7: this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) )
+ {
+ this_EQUAL_5=(Token)match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_ruleParam11007); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EQUAL_5, grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5063:1: ( (lv_defaultValue_6_0= ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5064:1: (lv_defaultValue_6_0= ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5064:1: (lv_defaultValue_6_0= ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5065:3: lv_defaultValue_6_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleParam11027);
+ lv_defaultValue_6_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getParamRule());
+ }
+ set(
+ current,
+ "defaultValue",
+ lv_defaultValue_6_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleParam"
+
+
+ // $ANTLR start "entryRuleNumberLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5089:1: entryRuleNumberLiteral returns [EObject current=null] : iv_ruleNumberLiteral= ruleNumberLiteral EOF ;
+ public final EObject entryRuleNumberLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleNumberLiteral = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5090:2: (iv_ruleNumberLiteral= ruleNumberLiteral EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5091:2: iv_ruleNumberLiteral= ruleNumberLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getNumberLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleNumberLiteral_in_entryRuleNumberLiteral11066);
+ iv_ruleNumberLiteral=ruleNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleNumberLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleNumberLiteral11076); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleNumberLiteral"
+
+
+ // $ANTLR start "ruleNumberLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5098:1: ruleNumberLiteral returns [EObject current=null] : ( () this_NUMBER_1= RULE_NUMBER ) ;
+ public final EObject ruleNumberLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_NUMBER_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5101:28: ( ( () this_NUMBER_1= RULE_NUMBER ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5102:1: ( () this_NUMBER_1= RULE_NUMBER )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5102:1: ( () this_NUMBER_1= RULE_NUMBER )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5102:2: () this_NUMBER_1= RULE_NUMBER
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5102:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5103:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_NUMBER_1=(Token)match(input,RULE_NUMBER,FOLLOW_RULE_NUMBER_in_ruleNumberLiteral11121); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_NUMBER_1, grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleNumberLiteral"
+
+
+ // $ANTLR start "entryRuleStringLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5120:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ;
+ public final EObject entryRuleStringLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleStringLiteral = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5121:2: (iv_ruleStringLiteral= ruleStringLiteral EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5122:2: iv_ruleStringLiteral= ruleStringLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getStringLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_entryRuleStringLiteral11156);
+ iv_ruleStringLiteral=ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleStringLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleStringLiteral11166); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleStringLiteral"
+
+
+ // $ANTLR start "ruleStringLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5129:1: ruleStringLiteral returns [EObject current=null] : ( () this_STRING_1= RULE_STRING ) ;
+ public final EObject ruleStringLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_STRING_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5132:28: ( ( () this_STRING_1= RULE_STRING ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5133:1: ( () this_STRING_1= RULE_STRING )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5133:1: ( () this_STRING_1= RULE_STRING )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5133:2: () this_STRING_1= RULE_STRING
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5133:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5134:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getStringLiteralAccess().getStringLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_STRING_1=(Token)match(input,RULE_STRING,FOLLOW_RULE_STRING_in_ruleStringLiteral11211); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_STRING_1, grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleStringLiteral"
+
+
+ // $ANTLR start "entryRuleBoolLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5151:1: entryRuleBoolLiteral returns [EObject current=null] : iv_ruleBoolLiteral= ruleBoolLiteral EOF ;
+ public final EObject entryRuleBoolLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleBoolLiteral = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5152:2: (iv_ruleBoolLiteral= ruleBoolLiteral EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5153:2: iv_ruleBoolLiteral= ruleBoolLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getBoolLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleBoolLiteral_in_entryRuleBoolLiteral11246);
+ iv_ruleBoolLiteral=ruleBoolLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleBoolLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBoolLiteral11256); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleBoolLiteral"
+
+
+ // $ANTLR start "ruleBoolLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5160:1: ruleBoolLiteral returns [EObject current=null] : ( () this_BOOL_1= RULE_BOOL ) ;
+ public final EObject ruleBoolLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_BOOL_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5163:28: ( ( () this_BOOL_1= RULE_BOOL ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5164:1: ( () this_BOOL_1= RULE_BOOL )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5164:1: ( () this_BOOL_1= RULE_BOOL )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5164:2: () this_BOOL_1= RULE_BOOL
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5164:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5165:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_BOOL_1=(Token)match(input,RULE_BOOL,FOLLOW_RULE_BOOL_in_ruleBoolLiteral11301); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_BOOL_1, grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleBoolLiteral"
+
+
+ // $ANTLR start "entryRuleJSLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5182:1: entryRuleJSLiteral returns [EObject current=null] : iv_ruleJSLiteral= ruleJSLiteral EOF ;
+ public final EObject entryRuleJSLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJSLiteral = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5183:2: (iv_ruleJSLiteral= ruleJSLiteral EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5184:2: iv_ruleJSLiteral= ruleJSLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJSLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleJSLiteral_in_entryRuleJSLiteral11336);
+ iv_ruleJSLiteral=ruleJSLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJSLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleJSLiteral11346); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJSLiteral"
+
+
+ // $ANTLR start "ruleJSLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5191:1: ruleJSLiteral returns [EObject current=null] : ( () this_JS_1= RULE_JS ) ;
+ public final EObject ruleJSLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_JS_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5194:28: ( ( () this_JS_1= RULE_JS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5195:1: ( () this_JS_1= RULE_JS )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5195:1: ( () this_JS_1= RULE_JS )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5195:2: () this_JS_1= RULE_JS
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5195:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5196:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getJSLiteralAccess().getJSLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_JS_1=(Token)match(input,RULE_JS,FOLLOW_RULE_JS_in_ruleJSLiteral11391); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_JS_1, grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJSLiteral"
+
+
+ // $ANTLR start "entryRuleRegexLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5213:1: entryRuleRegexLiteral returns [EObject current=null] : iv_ruleRegexLiteral= ruleRegexLiteral EOF ;
+ public final EObject entryRuleRegexLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRegexLiteral = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5214:2: (iv_ruleRegexLiteral= ruleRegexLiteral EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5215:2: iv_ruleRegexLiteral= ruleRegexLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getRegexLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleRegexLiteral_in_entryRuleRegexLiteral11426);
+ iv_ruleRegexLiteral=ruleRegexLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleRegexLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRegexLiteral11436); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRegexLiteral"
+
+
+ // $ANTLR start "ruleRegexLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5222:1: ruleRegexLiteral returns [EObject current=null] : ( () this_REGEX_1= RULE_REGEX ) ;
+ public final EObject ruleRegexLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_REGEX_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5225:28: ( ( () this_REGEX_1= RULE_REGEX ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5226:1: ( () this_REGEX_1= RULE_REGEX )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5226:1: ( () this_REGEX_1= RULE_REGEX )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5226:2: () this_REGEX_1= RULE_REGEX
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5226:2: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5227:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_REGEX_1=(Token)match(input,RULE_REGEX,FOLLOW_RULE_REGEX_in_ruleRegexLiteral11481); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_REGEX_1, grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRegexLiteral"
+
+
+ // $ANTLR start "entryRuleLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5244:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
+ public final EObject entryRuleLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleLiteral = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5245:2: (iv_ruleLiteral= ruleLiteral EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5246:2: iv_ruleLiteral= ruleLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleLiteral_in_entryRuleLiteral11516);
+ iv_ruleLiteral=ruleLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLiteral11526); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleLiteral"
+
+
+ // $ANTLR start "ruleLiteral"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5253:1: ruleLiteral returns [EObject current=null] : (this_NumberLiteral_0= ruleNumberLiteral | this_StringLiteral_1= ruleStringLiteral | this_BoolLiteral_2= ruleBoolLiteral | this_JSLiteral_3= ruleJSLiteral | this_RegexLiteral_4= ruleRegexLiteral ) ;
+ public final EObject ruleLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_NumberLiteral_0 = null;
+
+ EObject this_StringLiteral_1 = null;
+
+ EObject this_BoolLiteral_2 = null;
+
+ EObject this_JSLiteral_3 = null;
+
+ EObject this_RegexLiteral_4 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5256:28: ( (this_NumberLiteral_0= ruleNumberLiteral | this_StringLiteral_1= ruleStringLiteral | this_BoolLiteral_2= ruleBoolLiteral | this_JSLiteral_3= ruleJSLiteral | this_RegexLiteral_4= ruleRegexLiteral ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5257:1: (this_NumberLiteral_0= ruleNumberLiteral | this_StringLiteral_1= ruleStringLiteral | this_BoolLiteral_2= ruleBoolLiteral | this_JSLiteral_3= ruleJSLiteral | this_RegexLiteral_4= ruleRegexLiteral )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5257:1: (this_NumberLiteral_0= ruleNumberLiteral | this_StringLiteral_1= ruleStringLiteral | this_BoolLiteral_2= ruleBoolLiteral | this_JSLiteral_3= ruleJSLiteral | this_RegexLiteral_4= ruleRegexLiteral )
+ int alt93=5;
+ switch ( input.LA(1) ) {
+ case RULE_NUMBER:
+ {
+ alt93=1;
+ }
+ break;
+ case RULE_STRING:
+ {
+ alt93=2;
+ }
+ break;
+ case RULE_BOOL:
+ {
+ alt93=3;
+ }
+ break;
+ case RULE_JS:
+ {
+ alt93=4;
+ }
+ break;
+ case RULE_REGEX:
+ {
+ alt93=5;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 93, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt93) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5258:5: this_NumberLiteral_0= ruleNumberLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleNumberLiteral_in_ruleLiteral11573);
+ this_NumberLiteral_0=ruleNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_NumberLiteral_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5268:5: this_StringLiteral_1= ruleStringLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_ruleLiteral11600);
+ this_StringLiteral_1=ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_StringLiteral_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5278:5: this_BoolLiteral_2= ruleBoolLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleBoolLiteral_in_ruleLiteral11627);
+ this_BoolLiteral_2=ruleBoolLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_BoolLiteral_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 4 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5288:5: this_JSLiteral_3= ruleJSLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3());
+
+ }
+ pushFollow(FOLLOW_ruleJSLiteral_in_ruleLiteral11654);
+ this_JSLiteral_3=ruleJSLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_JSLiteral_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 5 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5298:5: this_RegexLiteral_4= ruleRegexLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4());
+
+ }
+ pushFollow(FOLLOW_ruleRegexLiteral_in_ruleLiteral11681);
+ this_RegexLiteral_4=ruleRegexLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_RegexLiteral_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleLiteral"
+
+
+ // $ANTLR start "entryRuleParenthetical"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5314:1: entryRuleParenthetical returns [EObject current=null] : iv_ruleParenthetical= ruleParenthetical EOF ;
+ public final EObject entryRuleParenthetical() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleParenthetical = null;
+
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5315:2: (iv_ruleParenthetical= ruleParenthetical EOF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5316:2: iv_ruleParenthetical= ruleParenthetical EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getParentheticalRule());
+ }
+ pushFollow(FOLLOW_ruleParenthetical_in_entryRuleParenthetical11716);
+ iv_ruleParenthetical=ruleParenthetical();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleParenthetical;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleParenthetical11726); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleParenthetical"
+
+
+ // $ANTLR start "ruleParenthetical"
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5323:1: ruleParenthetical returns [EObject current=null] : ( ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) ) ;
+ public final EObject ruleParenthetical() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LPAREN_0=null;
+ Token this_INDENT_1=null;
+ Token this_OUTDENT_3=null;
+ Token this_RPAREN_4=null;
+ Token this_LPAREN_5=null;
+ Token this_RPAREN_7=null;
+ EObject lv_content_2_0 = null;
+
+ EObject lv_content_6_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5326:28: ( ( ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:1: ( ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:1: ( ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) )
+ int alt94=2;
+ alt94 = dfa94.predict(input);
+ switch (alt94) {
+ case 1 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:2: ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:2: ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:3: ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:3: ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:4: ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:34: (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:35: this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT
+ {
+ this_LPAREN_0=(Token)match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_ruleParenthetical11774); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LPAREN_0, grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0());
+
+ }
+ this_INDENT_1=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleParenthetical11784); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_1, grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5335:3: ( (lv_content_2_0= ruleBody ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5336:1: (lv_content_2_0= ruleBody )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5336:1: (lv_content_2_0= ruleBody )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5337:3: lv_content_2_0= ruleBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBody_in_ruleParenthetical11806);
+ lv_content_2_0=ruleBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getParentheticalRule());
+ }
+ set(
+ current,
+ "content",
+ lv_content_2_0,
+ "Body");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_3=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleParenthetical11817); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_3, grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2());
+
+ }
+ this_RPAREN_4=(Token)match(input,RULE_RPAREN,FOLLOW_RULE_RPAREN_in_ruleParenthetical11827); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RPAREN_4, grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5362:6: ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5362:6: ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5362:7: ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5362:7: ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5362:8: ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN
+ {
+ this_LPAREN_5=(Token)match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_ruleParenthetical11851); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LPAREN_5, grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0());
+
+ }
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5366:2: ( (lv_content_6_0= ruleBody ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5367:1: (lv_content_6_0= ruleBody )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5367:1: (lv_content_6_0= ruleBody )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5368:3: lv_content_6_0= ruleBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBody_in_ruleParenthetical11872);
+ lv_content_6_0=ruleBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getParentheticalRule());
+ }
+ set(
+ current,
+ "content",
+ lv_content_6_0,
+ "Body");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_RPAREN_7=(Token)match(input,RULE_RPAREN,FOLLOW_RULE_RPAREN_in_ruleParenthetical11883); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RPAREN_7, grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleParenthetical"
+
+ // $ANTLR start synpred1_InternalCoffeeScript
+ public final void synpred1_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:245:7: ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:245:8: ( ( ( ruleId ) ) RULE_EQUAL 'require' )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:245:8: ( ( ( ruleId ) ) RULE_EQUAL 'require' )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:245:9: ( ( ruleId ) ) RULE_EQUAL 'require'
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:245:9: ( ( ruleId ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:246:1: ( ruleId )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:246:1: ( ruleId )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:247:1: ruleId
+ {
+ pushFollow(FOLLOW_ruleId_in_synpred1_InternalCoffeeScript558);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_synpred1_InternalCoffeeScript564); if (state.failed) return ;
+ match(input,85,FOLLOW_85_in_synpred1_InternalCoffeeScript566); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred1_InternalCoffeeScript
+
+ // $ANTLR start synpred3_InternalCoffeeScript
+ public final void synpred3_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:944:4: ( RULE_POST_IF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:944:6: RULE_POST_IF
+ {
+ match(input,RULE_POST_IF,FOLLOW_RULE_POST_IF_in_synpred3_InternalCoffeeScript2039); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred3_InternalCoffeeScript
+
+ // $ANTLR start synpred4_InternalCoffeeScript
+ public final void synpred4_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:973:8: ( RULE_FOR )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:973:10: RULE_FOR
+ {
+ match(input,RULE_FOR,FOLLOW_RULE_FOR_in_synpred4_InternalCoffeeScript2094); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred4_InternalCoffeeScript
+
+ // $ANTLR start synpred5_InternalCoffeeScript
+ public final void synpred5_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1002:8: ( RULE_WHILE )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1002:10: RULE_WHILE
+ {
+ match(input,RULE_WHILE,FOLLOW_RULE_WHILE_in_synpred5_InternalCoffeeScript2149); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred5_InternalCoffeeScript
+
+ // $ANTLR start synpred6_InternalCoffeeScript
+ public final void synpred6_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1030:4: ( RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1030:6: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred6_InternalCoffeeScript2197); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred6_InternalCoffeeScript
+
+ // $ANTLR start synpred7_InternalCoffeeScript
+ public final void synpred7_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1053:8: ( RULE_UNTIL )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1053:10: RULE_UNTIL
+ {
+ match(input,RULE_UNTIL,FOLLOW_RULE_UNTIL_in_synpred7_InternalCoffeeScript2245); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred7_InternalCoffeeScript
+
+ // $ANTLR start synpred8_InternalCoffeeScript
+ public final void synpred8_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1081:4: ( RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1081:6: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred8_InternalCoffeeScript2293); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred8_InternalCoffeeScript
+
+ // $ANTLR start synpred9_InternalCoffeeScript
+ public final void synpred9_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1243:5: ( RULE_FOROF )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1243:7: RULE_FOROF
+ {
+ match(input,RULE_FOROF,FOLLOW_RULE_FOROF_in_synpred9_InternalCoffeeScript2668); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred9_InternalCoffeeScript
+
+ // $ANTLR start synpred10_InternalCoffeeScript
+ public final void synpred10_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1265:4: ( RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1265:6: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred10_InternalCoffeeScript2707); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred10_InternalCoffeeScript
+
+ // $ANTLR start synpred11_InternalCoffeeScript
+ public final void synpred11_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1288:8: ( RULE_FORIN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1288:10: RULE_FORIN
+ {
+ match(input,RULE_FORIN,FOLLOW_RULE_FORIN_in_synpred11_InternalCoffeeScript2755); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred11_InternalCoffeeScript
+
+ // $ANTLR start synpred12_InternalCoffeeScript
+ public final void synpred12_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1310:5: ( RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1310:7: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred12_InternalCoffeeScript2795); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred12_InternalCoffeeScript
+
+ // $ANTLR start synpred13_InternalCoffeeScript
+ public final void synpred13_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1332:4: ( RULE_BY )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1332:6: RULE_BY
+ {
+ match(input,RULE_BY,FOLLOW_RULE_BY_in_synpred13_InternalCoffeeScript2834); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred13_InternalCoffeeScript
+
+ // $ANTLR start synpred14_InternalCoffeeScript
+ public final void synpred14_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1355:8: ( RULE_BY )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1355:10: RULE_BY
+ {
+ match(input,RULE_BY,FOLLOW_RULE_BY_in_synpred14_InternalCoffeeScript2882); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred14_InternalCoffeeScript
+
+ // $ANTLR start synpred15_InternalCoffeeScript
+ public final void synpred15_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1377:4: ( RULE_WHEN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1377:6: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred15_InternalCoffeeScript2921); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred15_InternalCoffeeScript
+
+ // $ANTLR start synpred17_InternalCoffeeScript
+ public final void synpred17_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:4: ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:5: ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:5: ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:6: ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1499:6: ( ( ruleAssignable ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1500:1: ( ruleAssignable )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1500:1: ( ruleAssignable )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1501:1: ruleAssignable
+ {
+ pushFollow(FOLLOW_ruleAssignable_in_synpred17_InternalCoffeeScript3235);
+ ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1503:2: ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1504:1: ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1504:1: ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1505:1: ( RULE_EQUAL | RULE_COMPOUND_ASSIGN )
+ {
+ if ( input.LA(1)==RULE_EQUAL||input.LA(1)==RULE_COMPOUND_ASSIGN ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred17_InternalCoffeeScript
+
+ // $ANTLR start synpred18_InternalCoffeeScript
+ public final void synpred18_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1683:3: ( ( () ( ( RULE_LOGIC ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1683:4: ( () ( ( RULE_LOGIC ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1683:4: ( () ( ( RULE_LOGIC ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1683:5: () ( ( RULE_LOGIC ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1683:5: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1684:1:
+ {
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1684:2: ( ( RULE_LOGIC ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1685:1: ( RULE_LOGIC )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1685:1: ( RULE_LOGIC )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1686:1: RULE_LOGIC
+ {
+ match(input,RULE_LOGIC,FOLLOW_RULE_LOGIC_in_synpred18_InternalCoffeeScript3659); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred18_InternalCoffeeScript
+
+ // $ANTLR start synpred19_InternalCoffeeScript
+ public final void synpred19_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1761:3: ( ( () ( ( RULE_COMPARE ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1761:4: ( () ( ( RULE_COMPARE ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1761:4: ( () ( ( RULE_COMPARE ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1761:5: () ( ( RULE_COMPARE ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1761:5: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1762:1:
+ {
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1762:2: ( ( RULE_COMPARE ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1763:1: ( RULE_COMPARE )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1763:1: ( RULE_COMPARE )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1764:1: RULE_COMPARE
+ {
+ match(input,RULE_COMPARE,FOLLOW_RULE_COMPARE_in_synpred19_InternalCoffeeScript3828); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred19_InternalCoffeeScript
+
+ // $ANTLR start synpred20_InternalCoffeeScript
+ public final void synpred20_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1839:3: ( ( () ( ( RULE_RELATION ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1839:4: ( () ( ( RULE_RELATION ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1839:4: ( () ( ( RULE_RELATION ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1839:5: () ( ( RULE_RELATION ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1839:5: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1840:1:
+ {
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1840:2: ( ( RULE_RELATION ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1841:1: ( RULE_RELATION )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1841:1: ( RULE_RELATION )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1842:1: RULE_RELATION
+ {
+ match(input,RULE_RELATION,FOLLOW_RULE_RELATION_in_synpred20_InternalCoffeeScript3997); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred20_InternalCoffeeScript
+
+ // $ANTLR start synpred21_InternalCoffeeScript
+ public final void synpred21_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1917:3: ( ( () ( ( RULE_SHIFT ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1917:4: ( () ( ( RULE_SHIFT ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1917:4: ( () ( ( RULE_SHIFT ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1917:5: () ( ( RULE_SHIFT ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1917:5: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1918:1:
+ {
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1918:2: ( ( RULE_SHIFT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1919:1: ( RULE_SHIFT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1919:1: ( RULE_SHIFT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1920:1: RULE_SHIFT
+ {
+ match(input,RULE_SHIFT,FOLLOW_RULE_SHIFT_in_synpred21_InternalCoffeeScript4166); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred21_InternalCoffeeScript
+
+ // $ANTLR start synpred22_InternalCoffeeScript
+ public final void synpred22_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1995:3: ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1995:4: ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1995:4: ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1995:5: () ( ( ( RULE_PLUS | RULE_MINUS ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1995:5: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1996:1:
+ {
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1996:2: ( ( ( RULE_PLUS | RULE_MINUS ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1997:1: ( ( RULE_PLUS | RULE_MINUS ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1997:1: ( ( RULE_PLUS | RULE_MINUS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:1998:1: ( RULE_PLUS | RULE_MINUS )
+ {
+ if ( (input.LA(1)>=RULE_PLUS && input.LA(1)<=RULE_MINUS) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred22_InternalCoffeeScript
+
+ // $ANTLR start synpred23_InternalCoffeeScript
+ public final void synpred23_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2096:3: ( ( () ( ( RULE_MATH ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2096:4: ( () ( ( RULE_MATH ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2096:4: ( () ( ( RULE_MATH ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2096:5: () ( ( RULE_MATH ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2096:5: ()
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2097:1:
+ {
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2097:2: ( ( RULE_MATH ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2098:1: ( RULE_MATH )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2098:1: ( RULE_MATH )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2099:1: RULE_MATH
+ {
+ match(input,RULE_MATH,FOLLOW_RULE_MATH_in_synpred23_InternalCoffeeScript4544); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred23_InternalCoffeeScript
+
+ // $ANTLR start synpred24_InternalCoffeeScript
+ public final void synpred24_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2666:4: ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2667:1: ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2667:1: ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2668:1: ( RULE_DOT_DOT | RULE_ELLIPSIS )
+ {
+ if ( (input.LA(1)>=RULE_DOT_DOT && input.LA(1)<=RULE_ELLIPSIS) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred24_InternalCoffeeScript
+
+ // $ANTLR start synpred25_InternalCoffeeScript
+ public final void synpred25_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:8: ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:9: ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:9: ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:10: ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2731:10: ( ( ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2732:1: ( ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2732:1: ( ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2733:1: ruleExpression
+ {
+ pushFollow(FOLLOW_ruleExpression_in_synpred25_InternalCoffeeScript5996);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2735:2: ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2736:1: ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2736:1: ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2737:1: ( RULE_DOT_DOT | RULE_ELLIPSIS )
+ {
+ if ( (input.LA(1)>=RULE_DOT_DOT && input.LA(1)<=RULE_ELLIPSIS) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred25_InternalCoffeeScript
+
+ // $ANTLR start synpred26_InternalCoffeeScript
+ public final void synpred26_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2887:7: ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2887:8: ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2887:8: ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2887:10: RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS )
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_synpred26_InternalCoffeeScript6306); if (state.failed) return ;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2887:23: ( ( ruleExpression ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2888:1: ( ruleExpression )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2888:1: ( ruleExpression )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2889:1: ruleExpression
+ {
+ pushFollow(FOLLOW_ruleExpression_in_synpred26_InternalCoffeeScript6311);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ if ( (input.LA(1)>=RULE_DOT_DOT && input.LA(1)<=RULE_ELLIPSIS) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred26_InternalCoffeeScript
+
+ // $ANTLR start synpred27_InternalCoffeeScript
+ public final void synpred27_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2902:7: ( RULE_LBRACKET )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2902:9: RULE_LBRACKET
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_synpred27_InternalCoffeeScript6362); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred27_InternalCoffeeScript
+
+ // $ANTLR start synpred28_InternalCoffeeScript
+ public final void synpred28_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2912:7: ( RULE_LCURLY )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:2912:9: RULE_LCURLY
+ {
+ match(input,RULE_LCURLY,FOLLOW_RULE_LCURLY_in_synpred28_InternalCoffeeScript6396); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred28_InternalCoffeeScript
+
+ // $ANTLR start synpred29_InternalCoffeeScript
+ public final void synpred29_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:4: ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:5: ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:5: ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:7: ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) )
+ {
+ pushFollow(FOLLOW_ruleIdRef_in_synpred29_InternalCoffeeScript8012);
+ ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3750:16: ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3751:1: ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3751:1: ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3752:1: ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT )
+ {
+ if ( (input.LA(1)>=RULE_DOT && input.LA(1)<=RULE_DOUBLE_COLON) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred29_InternalCoffeeScript
+
+ // $ANTLR start synpred30_InternalCoffeeScript
+ public final void synpred30_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:8: ( ( ruleIdRef RULE_INDEX_START ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:9: ( ruleIdRef RULE_INDEX_START )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:9: ( ruleIdRef RULE_INDEX_START )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:3841:11: ruleIdRef RULE_INDEX_START
+ {
+ pushFollow(FOLLOW_ruleIdRef_in_synpred30_InternalCoffeeScript8175);
+ ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ match(input,RULE_INDEX_START,FOLLOW_RULE_INDEX_START_in_synpred30_InternalCoffeeScript8177); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred30_InternalCoffeeScript
+
+ // $ANTLR start synpred32_InternalCoffeeScript
+ public final void synpred32_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4148:7: ( RULE_LCURLY )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4148:9: RULE_LCURLY
+ {
+ match(input,RULE_LCURLY,FOLLOW_RULE_LCURLY_in_synpred32_InternalCoffeeScript8930); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred32_InternalCoffeeScript
+
+ // $ANTLR start synpred33_InternalCoffeeScript
+ public final void synpred33_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4158:7: ( RULE_LBRACKET )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:4158:9: RULE_LBRACKET
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_synpred33_InternalCoffeeScript8964); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred33_InternalCoffeeScript
+
+ // $ANTLR start synpred36_InternalCoffeeScript
+ public final void synpred36_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5011:7: ( RULE_LBRACKET )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5011:9: RULE_LBRACKET
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_synpred36_InternalCoffeeScript10888); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred36_InternalCoffeeScript
+
+ // $ANTLR start synpred37_InternalCoffeeScript
+ public final void synpred37_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5021:7: ( RULE_LCURLY )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5021:9: RULE_LCURLY
+ {
+ match(input,RULE_LCURLY,FOLLOW_RULE_LCURLY_in_synpred37_InternalCoffeeScript10922); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred37_InternalCoffeeScript
+
+ // $ANTLR start synpred38_InternalCoffeeScript
+ public final void synpred38_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:4: ( ( RULE_LPAREN RULE_INDENT ) )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:5: ( RULE_LPAREN RULE_INDENT )
+ {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:5: ( RULE_LPAREN RULE_INDENT )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5327:7: RULE_LPAREN RULE_INDENT
+ {
+ match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_synpred38_InternalCoffeeScript11765); if (state.failed) return ;
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_synpred38_InternalCoffeeScript11767); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred38_InternalCoffeeScript
+
+ // $ANTLR start synpred39_InternalCoffeeScript
+ public final void synpred39_InternalCoffeeScript_fragment() throws RecognitionException {
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5362:8: ( RULE_LPAREN )
+ // ../csep/src-gen/csep/parser/antlr/internal/InternalCoffeeScript.g:5362:10: RULE_LPAREN
+ {
+ match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_synpred39_InternalCoffeeScript11846); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred39_InternalCoffeeScript
+
+ // Delegated rules
+
+ public final boolean synpred30_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred30_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred1_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred1_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred7_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred7_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred6_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred6_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred12_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred12_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred5_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred5_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred37_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred37_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred9_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred9_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred4_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred4_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred19_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred19_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred32_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred32_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred13_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred13_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred24_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred24_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred3_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred3_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred14_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred14_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred26_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred26_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred11_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred11_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred20_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred20_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred23_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred23_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred17_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred17_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred28_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred28_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred38_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred38_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred36_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred36_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred27_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred27_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred8_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred8_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred29_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred29_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred21_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred21_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred18_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred18_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred15_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred15_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred25_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred25_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred33_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred33_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred39_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred39_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred10_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred10_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred22_InternalCoffeeScript() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred22_InternalCoffeeScript_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+
+
+ protected DFA18 dfa18 = new DFA18(this);
+ protected DFA28 dfa28 = new DFA28(this);
+ protected DFA53 dfa53 = new DFA53(this);
+ protected DFA61 dfa61 = new DFA61(this);
+ protected DFA94 dfa94 = new DFA94(this);
+ static final String DFA18_eotS =
+ "\12\uffff";
+ static final String DFA18_eofS =
+ "\1\5\11\uffff";
+ static final String DFA18_minS =
+ "\1\4\4\0\5\uffff";
+ static final String DFA18_maxS =
+ "\1\111\4\0\5\uffff";
+ static final String DFA18_acceptS =
+ "\5\uffff\1\5\1\1\1\2\1\3\1\4";
+ static final String DFA18_specialS =
+ "\1\uffff\1\3\1\2\1\1\1\0\5\uffff}>";
+ static final String[] DFA18_transitionS = {
+ "\1\5\5\uffff\1\5\1\uffff\1\1\3\uffff\1\2\1\3\1\5\1\4\1\uffff"+
+ "\1\5\2\uffff\1\5\1\uffff\3\5\1\uffff\11\5\13\uffff\1\5\13\uffff"+
+ "\1\5\2\uffff\1\5\7\uffff\1\5",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA18_eot = DFA.unpackEncodedString(DFA18_eotS);
+ static final short[] DFA18_eof = DFA.unpackEncodedString(DFA18_eofS);
+ static final char[] DFA18_min = DFA.unpackEncodedStringToUnsignedChars(DFA18_minS);
+ static final char[] DFA18_max = DFA.unpackEncodedStringToUnsignedChars(DFA18_maxS);
+ static final short[] DFA18_accept = DFA.unpackEncodedString(DFA18_acceptS);
+ static final short[] DFA18_special = DFA.unpackEncodedString(DFA18_specialS);
+ static final short[][] DFA18_transition;
+
+ static {
+ int numStates = DFA18_transitionS.length;
+ DFA18_transition = new short[numStates][];
+ for (int i=0; ithis_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA18_4 = input.LA(1);
+
+
+ int index18_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalCoffeeScript()) ) {s = 9;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index18_4);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA18_3 = input.LA(1);
+
+
+ int index18_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred5_InternalCoffeeScript()) ) {s = 8;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index18_3);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA18_2 = input.LA(1);
+
+
+ int index18_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred4_InternalCoffeeScript()) ) {s = 7;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index18_2);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA18_1 = input.LA(1);
+
+
+ int index18_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred3_InternalCoffeeScript()) ) {s = 6;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index18_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 18, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA28_eotS =
+ "\35\uffff";
+ static final String DFA28_eofS =
+ "\35\uffff";
+ static final String DFA28_minS =
+ "\1\11\5\0\27\uffff";
+ static final String DFA28_maxS =
+ "\1\110\5\0\27\uffff";
+ static final String DFA28_acceptS =
+ "\6\uffff\1\2\25\uffff\1\1";
+ static final String DFA28_specialS =
+ "\1\uffff\1\0\1\1\1\2\1\3\1\4\27\uffff}>";
+ static final String[] DFA28_transitionS = {
+ "\1\6\6\uffff\2\6\1\uffff\1\6\5\uffff\1\5\12\uffff\2\6\1\uffff"+
+ "\3\6\1\uffff\1\6\1\uffff\1\2\5\uffff\1\3\2\6\2\uffff\1\6\2\uffff"+
+ "\1\6\1\1\1\4\2\uffff\1\6\1\uffff\7\6",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS);
+ static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS);
+ static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS);
+ static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS);
+ static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS);
+ static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS);
+ static final short[][] DFA28_transition;
+
+ static {
+ int numStates = DFA28_transitionS.length;
+ DFA28_transition = new short[numStates][];
+ for (int i=0; i ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA28_1 = input.LA(1);
+
+
+ int index28_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCoffeeScript()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index28_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA28_2 = input.LA(1);
+
+
+ int index28_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCoffeeScript()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index28_2);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA28_3 = input.LA(1);
+
+
+ int index28_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCoffeeScript()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index28_3);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA28_4 = input.LA(1);
+
+
+ int index28_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCoffeeScript()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index28_4);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA28_5 = input.LA(1);
+
+
+ int index28_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCoffeeScript()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index28_5);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 28, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA53_eotS =
+ "\40\uffff";
+ static final String DFA53_eofS =
+ "\40\uffff";
+ static final String DFA53_minS =
+ "\1\11\2\uffff\33\0\2\uffff";
+ static final String DFA53_maxS =
+ "\1\110\2\uffff\33\0\2\uffff";
+ static final String DFA53_acceptS =
+ "\1\uffff\2\1\33\uffff\1\2\1\3";
+ static final String DFA53_specialS =
+ "\1\0\2\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
+ "\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31"+
+ "\1\32\1\33\2\uffff}>";
+ static final String[] DFA53_transitionS = {
+ "\1\21\6\uffff\1\30\1\31\1\uffff\1\32\5\uffff\1\7\1\1\1\2\10"+
+ "\uffff\1\11\1\12\1\uffff\1\10\1\13\1\14\1\uffff\1\15\1\uffff"+
+ "\1\4\5\uffff\1\5\1\33\1\34\2\uffff\1\35\2\uffff\1\16\1\3\1\6"+
+ "\2\uffff\1\25\1\uffff\1\26\1\27\1\20\1\22\1\23\1\24\1\17",
+ "",
+ "",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ ""
+ };
+
+ static final short[] DFA53_eot = DFA.unpackEncodedString(DFA53_eotS);
+ static final short[] DFA53_eof = DFA.unpackEncodedString(DFA53_eofS);
+ static final char[] DFA53_min = DFA.unpackEncodedStringToUnsignedChars(DFA53_minS);
+ static final char[] DFA53_max = DFA.unpackEncodedStringToUnsignedChars(DFA53_maxS);
+ static final short[] DFA53_accept = DFA.unpackEncodedString(DFA53_acceptS);
+ static final short[] DFA53_special = DFA.unpackEncodedString(DFA53_specialS);
+ static final short[][] DFA53_transition;
+
+ static {
+ int numStates = DFA53_transitionS.length;
+ DFA53_transition = new short[numStates][];
+ for (int i=0; i ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA53_0 = input.LA(1);
+
+
+ int index53_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA53_0==RULE_DOT_DOT) && (synpred24_InternalCoffeeScript())) {s = 1;}
+
+ else if ( (LA53_0==RULE_ELLIPSIS) && (synpred24_InternalCoffeeScript())) {s = 2;}
+
+ else if ( (LA53_0==RULE_IDENTIFIER) ) {s = 3;}
+
+ else if ( (LA53_0==RULE_AT_SIGIL) ) {s = 4;}
+
+ else if ( (LA53_0==RULE_THIS) ) {s = 5;}
+
+ else if ( (LA53_0==RULE_LCURLY) ) {s = 6;}
+
+ else if ( (LA53_0==RULE_LBRACKET) ) {s = 7;}
+
+ else if ( (LA53_0==RULE_UNARY) ) {s = 8;}
+
+ else if ( (LA53_0==RULE_PLUS) ) {s = 9;}
+
+ else if ( (LA53_0==RULE_MINUS) ) {s = 10;}
+
+ else if ( (LA53_0==RULE_PLUS_PLUS) ) {s = 11;}
+
+ else if ( (LA53_0==RULE_MINUS_MINUS) ) {s = 12;}
+
+ else if ( (LA53_0==RULE_SUPER) ) {s = 13;}
+
+ else if ( (LA53_0==RULE_IF) ) {s = 14;}
+
+ else if ( (LA53_0==RULE_LPAREN) ) {s = 15;}
+
+ else if ( (LA53_0==RULE_NUMBER) ) {s = 16;}
+
+ else if ( (LA53_0==RULE_STRING) ) {s = 17;}
+
+ else if ( (LA53_0==RULE_BOOL) ) {s = 18;}
+
+ else if ( (LA53_0==RULE_JS) ) {s = 19;}
+
+ else if ( (LA53_0==RULE_REGEX) ) {s = 20;}
+
+ else if ( (LA53_0==RULE_PARAM_START) ) {s = 21;}
+
+ else if ( (LA53_0==RULE_FUNC_ARROW) ) {s = 22;}
+
+ else if ( (LA53_0==RULE_BOUND_FUNC_ARROW) ) {s = 23;}
+
+ else if ( (LA53_0==RULE_FOR) ) {s = 24;}
+
+ else if ( (LA53_0==RULE_WHILE) ) {s = 25;}
+
+ else if ( (LA53_0==RULE_UNTIL) ) {s = 26;}
+
+ else if ( (LA53_0==RULE_LOOP) ) {s = 27;}
+
+ else if ( (LA53_0==RULE_TRY) ) {s = 28;}
+
+ else if ( (LA53_0==RULE_SWITCH) ) {s = 29;}
+
+
+ input.seek(index53_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA53_3 = input.LA(1);
+
+
+ int index53_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_3);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA53_4 = input.LA(1);
+
+
+ int index53_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_4);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA53_5 = input.LA(1);
+
+
+ int index53_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_5);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA53_6 = input.LA(1);
+
+
+ int index53_6 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_6);
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA53_7 = input.LA(1);
+
+
+ int index53_7 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_7);
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA53_8 = input.LA(1);
+
+
+ int index53_8 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_8);
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA53_9 = input.LA(1);
+
+
+ int index53_9 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_9);
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA53_10 = input.LA(1);
+
+
+ int index53_10 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_10);
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA53_11 = input.LA(1);
+
+
+ int index53_11 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_11);
+ if ( s>=0 ) return s;
+ break;
+ case 10 :
+ int LA53_12 = input.LA(1);
+
+
+ int index53_12 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_12);
+ if ( s>=0 ) return s;
+ break;
+ case 11 :
+ int LA53_13 = input.LA(1);
+
+
+ int index53_13 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_13);
+ if ( s>=0 ) return s;
+ break;
+ case 12 :
+ int LA53_14 = input.LA(1);
+
+
+ int index53_14 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_14);
+ if ( s>=0 ) return s;
+ break;
+ case 13 :
+ int LA53_15 = input.LA(1);
+
+
+ int index53_15 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_15);
+ if ( s>=0 ) return s;
+ break;
+ case 14 :
+ int LA53_16 = input.LA(1);
+
+
+ int index53_16 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_16);
+ if ( s>=0 ) return s;
+ break;
+ case 15 :
+ int LA53_17 = input.LA(1);
+
+
+ int index53_17 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_17);
+ if ( s>=0 ) return s;
+ break;
+ case 16 :
+ int LA53_18 = input.LA(1);
+
+
+ int index53_18 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_18);
+ if ( s>=0 ) return s;
+ break;
+ case 17 :
+ int LA53_19 = input.LA(1);
+
+
+ int index53_19 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_19);
+ if ( s>=0 ) return s;
+ break;
+ case 18 :
+ int LA53_20 = input.LA(1);
+
+
+ int index53_20 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_20);
+ if ( s>=0 ) return s;
+ break;
+ case 19 :
+ int LA53_21 = input.LA(1);
+
+
+ int index53_21 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_21);
+ if ( s>=0 ) return s;
+ break;
+ case 20 :
+ int LA53_22 = input.LA(1);
+
+
+ int index53_22 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_22);
+ if ( s>=0 ) return s;
+ break;
+ case 21 :
+ int LA53_23 = input.LA(1);
+
+
+ int index53_23 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_23);
+ if ( s>=0 ) return s;
+ break;
+ case 22 :
+ int LA53_24 = input.LA(1);
+
+
+ int index53_24 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_24);
+ if ( s>=0 ) return s;
+ break;
+ case 23 :
+ int LA53_25 = input.LA(1);
+
+
+ int index53_25 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_25);
+ if ( s>=0 ) return s;
+ break;
+ case 24 :
+ int LA53_26 = input.LA(1);
+
+
+ int index53_26 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_26);
+ if ( s>=0 ) return s;
+ break;
+ case 25 :
+ int LA53_27 = input.LA(1);
+
+
+ int index53_27 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_27);
+ if ( s>=0 ) return s;
+ break;
+ case 26 :
+ int LA53_28 = input.LA(1);
+
+
+ int index53_28 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_28);
+ if ( s>=0 ) return s;
+ break;
+ case 27 :
+ int LA53_29 = input.LA(1);
+
+
+ int index53_29 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCoffeeScript()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index53_29);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 53, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA61_eotS =
+ "\30\uffff";
+ static final String DFA61_eofS =
+ "\30\uffff";
+ static final String DFA61_minS =
+ "\1\11\7\uffff\1\0\17\uffff";
+ static final String DFA61_maxS =
+ "\1\110\7\uffff\1\0\17\uffff";
+ static final String DFA61_acceptS =
+ "\1\uffff\1\1\1\2\1\3\5\uffff\1\6\1\7\2\uffff\1\10\1\11\1\12\1\13"+
+ "\1\14\1\15\1\16\1\17\1\20\1\4\1\5";
+ static final String DFA61_specialS =
+ "\1\0\7\uffff\1\1\17\uffff}>";
+ static final String[] DFA61_transitionS = {
+ "\1\3\6\uffff\1\17\1\20\1\uffff\1\21\5\uffff\1\10\23\uffff\1"+
+ "\15\5\uffff\1\16\1\22\1\23\2\uffff\1\24\2\uffff\1\1\1\25\1\11"+
+ "\2\uffff\1\12\1\uffff\2\12\4\3\1\2",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA61_eot = DFA.unpackEncodedString(DFA61_eotS);
+ static final short[] DFA61_eof = DFA.unpackEncodedString(DFA61_eofS);
+ static final char[] DFA61_min = DFA.unpackEncodedStringToUnsignedChars(DFA61_minS);
+ static final char[] DFA61_max = DFA.unpackEncodedStringToUnsignedChars(DFA61_maxS);
+ static final short[] DFA61_accept = DFA.unpackEncodedString(DFA61_acceptS);
+ static final short[] DFA61_special = DFA.unpackEncodedString(DFA61_specialS);
+ static final short[][] DFA61_transition;
+
+ static {
+ int numStates = DFA61_transitionS.length;
+ DFA61_transition = new short[numStates][];
+ for (int i=0; ithis_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA61_0 = input.LA(1);
+
+
+ int index61_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA61_0==RULE_IF) ) {s = 1;}
+
+ else if ( (LA61_0==RULE_LPAREN) ) {s = 2;}
+
+ else if ( (LA61_0==RULE_STRING||(LA61_0>=RULE_NUMBER && LA61_0<=RULE_REGEX)) ) {s = 3;}
+
+ else if ( (LA61_0==RULE_LBRACKET) ) {s = 8;}
+
+ else if ( (LA61_0==RULE_LCURLY) && (synpred28_InternalCoffeeScript())) {s = 9;}
+
+ else if ( (LA61_0==RULE_PARAM_START||(LA61_0>=RULE_FUNC_ARROW && LA61_0<=RULE_BOUND_FUNC_ARROW)) ) {s = 10;}
+
+ else if ( (LA61_0==RULE_AT_SIGIL) ) {s = 13;}
+
+ else if ( (LA61_0==RULE_THIS) ) {s = 14;}
+
+ else if ( (LA61_0==RULE_FOR) ) {s = 15;}
+
+ else if ( (LA61_0==RULE_WHILE) ) {s = 16;}
+
+ else if ( (LA61_0==RULE_UNTIL) ) {s = 17;}
+
+ else if ( (LA61_0==RULE_LOOP) ) {s = 18;}
+
+ else if ( (LA61_0==RULE_TRY) ) {s = 19;}
+
+ else if ( (LA61_0==RULE_SWITCH) ) {s = 20;}
+
+ else if ( (LA61_0==RULE_IDENTIFIER) ) {s = 21;}
+
+
+ input.seek(index61_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA61_8 = input.LA(1);
+
+
+ int index61_8 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred26_InternalCoffeeScript()) ) {s = 22;}
+
+ else if ( (synpred27_InternalCoffeeScript()) ) {s = 23;}
+
+
+ input.seek(index61_8);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 61, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA94_eotS =
+ "\43\uffff";
+ static final String DFA94_eofS =
+ "\43\uffff";
+ static final String DFA94_minS =
+ "\1\110\1\5\41\uffff";
+ static final String DFA94_maxS =
+ "\2\110\41\uffff";
+ static final String DFA94_acceptS =
+ "\2\uffff\1\1\40\2";
+ static final String DFA94_specialS =
+ "\1\uffff\1\0\41\uffff}>";
+ static final String[] DFA94_transitionS = {
+ "\1\1",
+ "\1\10\1\6\2\uffff\1\26\1\uffff\1\3\1\uffff\1\4\1\7\1\uffff"+
+ "\1\35\1\36\1\uffff\1\37\5\uffff\1\14\4\uffff\1\2\5\uffff\1\16"+
+ "\1\17\1\uffff\1\15\1\20\1\21\1\uffff\1\22\1\uffff\1\11\5\uffff"+
+ "\1\12\1\40\1\41\2\uffff\1\42\2\uffff\1\23\1\5\1\13\2\uffff\1"+
+ "\32\1\uffff\1\33\1\34\1\25\1\27\1\30\1\31\1\24",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA94_eot = DFA.unpackEncodedString(DFA94_eotS);
+ static final short[] DFA94_eof = DFA.unpackEncodedString(DFA94_eofS);
+ static final char[] DFA94_min = DFA.unpackEncodedStringToUnsignedChars(DFA94_minS);
+ static final char[] DFA94_max = DFA.unpackEncodedStringToUnsignedChars(DFA94_maxS);
+ static final short[] DFA94_accept = DFA.unpackEncodedString(DFA94_acceptS);
+ static final short[] DFA94_special = DFA.unpackEncodedString(DFA94_specialS);
+ static final short[][] DFA94_transition;
+
+ static {
+ int numStates = DFA94_transitionS.length;
+ DFA94_transition = new short[numStates][];
+ for (int i=0; i (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA94_1 = input.LA(1);
+
+
+ int index94_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA94_1==RULE_INDENT) && (synpred38_InternalCoffeeScript())) {s = 2;}
+
+ else if ( (LA94_1==RULE_RETURN) && (synpred39_InternalCoffeeScript())) {s = 3;}
+
+ else if ( (LA94_1==RULE_THROW) && (synpred39_InternalCoffeeScript())) {s = 4;}
+
+ else if ( (LA94_1==RULE_IDENTIFIER) && (synpred39_InternalCoffeeScript())) {s = 5;}
+
+ else if ( (LA94_1==RULE_HERECOMMENT) && (synpred39_InternalCoffeeScript())) {s = 6;}
+
+ else if ( (LA94_1==RULE_CLASS) && (synpred39_InternalCoffeeScript())) {s = 7;}
+
+ else if ( (LA94_1==RULE_STATEMENT) && (synpred39_InternalCoffeeScript())) {s = 8;}
+
+ else if ( (LA94_1==RULE_AT_SIGIL) && (synpred39_InternalCoffeeScript())) {s = 9;}
+
+ else if ( (LA94_1==RULE_THIS) && (synpred39_InternalCoffeeScript())) {s = 10;}
+
+ else if ( (LA94_1==RULE_LCURLY) && (synpred39_InternalCoffeeScript())) {s = 11;}
+
+ else if ( (LA94_1==RULE_LBRACKET) && (synpred39_InternalCoffeeScript())) {s = 12;}
+
+ else if ( (LA94_1==RULE_UNARY) && (synpred39_InternalCoffeeScript())) {s = 13;}
+
+ else if ( (LA94_1==RULE_PLUS) && (synpred39_InternalCoffeeScript())) {s = 14;}
+
+ else if ( (LA94_1==RULE_MINUS) && (synpred39_InternalCoffeeScript())) {s = 15;}
+
+ else if ( (LA94_1==RULE_PLUS_PLUS) && (synpred39_InternalCoffeeScript())) {s = 16;}
+
+ else if ( (LA94_1==RULE_MINUS_MINUS) && (synpred39_InternalCoffeeScript())) {s = 17;}
+
+ else if ( (LA94_1==RULE_SUPER) && (synpred39_InternalCoffeeScript())) {s = 18;}
+
+ else if ( (LA94_1==RULE_IF) && (synpred39_InternalCoffeeScript())) {s = 19;}
+
+ else if ( (LA94_1==RULE_LPAREN) && (synpred39_InternalCoffeeScript())) {s = 20;}
+
+ else if ( (LA94_1==RULE_NUMBER) && (synpred39_InternalCoffeeScript())) {s = 21;}
+
+ else if ( (LA94_1==RULE_STRING) && (synpred39_InternalCoffeeScript())) {s = 22;}
+
+ else if ( (LA94_1==RULE_BOOL) && (synpred39_InternalCoffeeScript())) {s = 23;}
+
+ else if ( (LA94_1==RULE_JS) && (synpred39_InternalCoffeeScript())) {s = 24;}
+
+ else if ( (LA94_1==RULE_REGEX) && (synpred39_InternalCoffeeScript())) {s = 25;}
+
+ else if ( (LA94_1==RULE_PARAM_START) && (synpred39_InternalCoffeeScript())) {s = 26;}
+
+ else if ( (LA94_1==RULE_FUNC_ARROW) && (synpred39_InternalCoffeeScript())) {s = 27;}
+
+ else if ( (LA94_1==RULE_BOUND_FUNC_ARROW) && (synpred39_InternalCoffeeScript())) {s = 28;}
+
+ else if ( (LA94_1==RULE_FOR) && (synpred39_InternalCoffeeScript())) {s = 29;}
+
+ else if ( (LA94_1==RULE_WHILE) && (synpred39_InternalCoffeeScript())) {s = 30;}
+
+ else if ( (LA94_1==RULE_UNTIL) && (synpred39_InternalCoffeeScript())) {s = 31;}
+
+ else if ( (LA94_1==RULE_LOOP) && (synpred39_InternalCoffeeScript())) {s = 32;}
+
+ else if ( (LA94_1==RULE_TRY) && (synpred39_InternalCoffeeScript())) {s = 33;}
+
+ else if ( (LA94_1==RULE_SWITCH) && (synpred39_InternalCoffeeScript())) {s = 34;}
+
+
+ input.seek(index94_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 94, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+ public static final BitSet FOLLOW_ruleRoot_in_entryRuleRoot75 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRoot85 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBody_in_ruleRoot132 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleRoot160 = new BitSet(new long[]{0x0000000000000010L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleRoot170 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBody_in_entryRuleBody207 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleBody217 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLine_in_ruleBody263 = new BitSet(new long[]{0x0000000000000012L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleBody275 = new BitSet(new long[]{0x39382BB0020B6A72L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleLine_in_ruleBody295 = new BitSet(new long[]{0x0000000000000012L});
+ public static final BitSet FOLLOW_ruleLine_in_entryRuleLine334 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLine344 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStmt_in_ruleLine391 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleLine418 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStmt_in_entryRuleStmt453 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleStmt463 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleReturnStmt_in_ruleStmt510 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThrowStmt_in_ruleStmt537 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRequireStmt_in_ruleStmt585 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleComment_in_ruleStmt613 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleClassDeclaration_in_ruleStmt640 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_STATEMENT_in_ruleStmt662 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleComment_in_entryRuleComment703 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleComment713 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_HERECOMMENT_in_ruleComment754 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRequireStmt_in_entryRuleRequireStmt794 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRequireStmt804 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleRequireStmt872 = new BitSet(new long[]{0x0000000000000080L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_ruleRequireStmt883 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
+ public static final BitSet FOLLOW_85_in_ruleRequireStmt894 = new BitSet(new long[]{0x0000000000000100L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_ruleRequireStmt907 = new BitSet(new long[]{0x0000000000000200L});
+ public static final BitSet FOLLOW_RULE_STRING_in_ruleRequireStmt923 = new BitSet(new long[]{0x0000000000000400L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_ruleRequireStmt939 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleReturnStmt_in_entryRuleReturnStmt974 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleReturnStmt984 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RETURN_in_ruleReturnStmt1029 = new BitSet(new long[]{0x39382BB0020B7A62L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleReturnStmt1049 = new BitSet(new long[]{0x0000000000001002L});
+ public static final BitSet FOLLOW_RULE_POST_IF_in_ruleReturnStmt1062 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleReturnStmt1082 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThrowStmt_in_entryRuleThrowStmt1120 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleThrowStmt1130 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_THROW_in_ruleThrowStmt1166 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleThrowStmt1186 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_entryRuleSuperClass1222 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleSuperClass1232 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_ruleSuperClass1279 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_ruleSuperClass1306 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleClassDeclaration_in_entryRuleClassDeclaration1341 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleClassDeclaration1351 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CLASS_in_ruleClassDeclaration1396 = new BitSet(new long[]{0x1008200040008002L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleClassDeclaration1417 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_ruleClassDeclaration1435 = new BitSet(new long[]{0x1008200000000000L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_ruleClassDeclaration1455 = new BitSet(new long[]{0x0000000040000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleClassDeclaration1476 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleClassDeclaration1508 = new BitSet(new long[]{0x0000000040008000L});
+ public static final BitSet FOLLOW_ruleProperty_in_ruleClassDeclaration1527 = new BitSet(new long[]{0x0000000040008000L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_ruleClassDeclaration1542 = new BitSet(new long[]{0x1008200000000000L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_ruleClassDeclaration1562 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleClassDeclaration1585 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignedClassDeclaration_in_entryRuleAssignedClassDeclaration1624 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignedClassDeclaration1634 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CLASS_in_ruleAssignedClassDeclaration1679 = new BitSet(new long[]{0x1008200000008002L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_ruleAssignedClassDeclaration1691 = new BitSet(new long[]{0x1008200000000000L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_ruleAssignedClassDeclaration1711 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleAssignedClassDeclaration1732 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleAssignedClassDeclaration1763 = new BitSet(new long[]{0x0000000040008000L});
+ public static final BitSet FOLLOW_ruleProperty_in_ruleAssignedClassDeclaration1782 = new BitSet(new long[]{0x0000000040008000L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_ruleAssignedClassDeclaration1797 = new BitSet(new long[]{0x1008200000000000L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_ruleAssignedClassDeclaration1817 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleAssignedClassDeclaration1840 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_entryRuleExpression1879 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleExpression1889 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePostfix_in_ruleExpression1935 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePostfix_in_entryRulePostfix1969 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRulePostfix1979 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignment_in_rulePostfix2026 = new BitSet(new long[]{0x00000000000B1002L});
+ public static final BitSet FOLLOW_RULE_POST_IF_in_rulePostfix2044 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2074 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOR_in_rulePostfix2099 = new BitSet(new long[]{0x1000000000100000L});
+ public static final BitSet FOLLOW_ruleForBody_in_rulePostfix2129 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHILE_in_rulePostfix2154 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2184 = new BitSet(new long[]{0x0000000000040002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rulePostfix2202 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2223 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNTIL_in_rulePostfix2250 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2280 = new BitSet(new long[]{0x0000000000040002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rulePostfix2298 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2319 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForBody_in_entryRuleForBody2360 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleForBody2370 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OWN_in_ruleForBody2407 = new BitSet(new long[]{0x1000000000100000L});
+ public static final BitSet FOLLOW_ruleForValue_in_ruleForBody2429 = new BitSet(new long[]{0x0000000000E00000L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleForBody2441 = new BitSet(new long[]{0x1000000000100000L});
+ public static final BitSet FOLLOW_ruleForValue_in_ruleForBody2461 = new BitSet(new long[]{0x0000000000E00000L});
+ public static final BitSet FOLLOW_ruleForSource_in_ruleForBody2484 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForValue_in_entryRuleForValue2520 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleForValue2530 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleForValue2576 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForSource_in_entryRuleForSource2610 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleForSource2620 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOROF_in_ruleForSource2673 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2694 = new BitSet(new long[]{0x0000000000040002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_ruleForSource2712 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2733 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FORIN_in_ruleForSource2760 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2781 = new BitSet(new long[]{0x0000000001040002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_ruleForSource2800 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2821 = new BitSet(new long[]{0x0000000001000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_ruleForSource2839 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2860 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_ruleForSource2887 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2908 = new BitSet(new long[]{0x0000000000040002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_ruleForSource2926 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2947 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRange_in_entryRuleRange2990 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRange3000 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_ruleRange3066 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleRange3086 = new BitSet(new long[]{0x000000000C000000L});
+ public static final BitSet FOLLOW_RULE_DOT_DOT_in_ruleRange3098 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleRange3114 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleRange3137 = new BitSet(new long[]{0x0000000010000000L});
+ public static final BitSet FOLLOW_RULE_RBRACKET_in_ruleRange3148 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignment_in_entryRuleAssignment3183 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignment3193 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_ruleAssignment3281 = new BitSet(new long[]{0x0000000020000080L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_ruleAssignment3300 = new BitSet(new long[]{0x39382BB0420B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_RULE_COMPOUND_ASSIGN_in_ruleAssignment3320 = new BitSet(new long[]{0x39382BB0420B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleAssigned_in_ruleAssignment3351 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLogicOp_in_ruleAssignment3380 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssigned_in_entryRuleAssigned3415 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssigned3425 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleAssigned3472 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleAssigned3489 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleAssigned3510 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleAssigned3520 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignedClassDeclaration_in_ruleAssigned3548 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLogicOp_in_entryRuleLogicOp3583 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLogicOp3593 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCompareOp_in_ruleLogicOp3640 = new BitSet(new long[]{0x0000000100000002L});
+ public static final BitSet FOLLOW_RULE_LOGIC_in_ruleLogicOp3686 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleCompareOp_in_ruleLogicOp3714 = new BitSet(new long[]{0x0000000100000002L});
+ public static final BitSet FOLLOW_ruleCompareOp_in_entryRuleCompareOp3752 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCompareOp3762 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRelationOp_in_ruleCompareOp3809 = new BitSet(new long[]{0x0000000200000002L});
+ public static final BitSet FOLLOW_RULE_COMPARE_in_ruleCompareOp3855 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleRelationOp_in_ruleCompareOp3883 = new BitSet(new long[]{0x0000000200000002L});
+ public static final BitSet FOLLOW_ruleRelationOp_in_entryRuleRelationOp3921 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRelationOp3931 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleShiftOp_in_ruleRelationOp3978 = new BitSet(new long[]{0x0000000400000002L});
+ public static final BitSet FOLLOW_RULE_RELATION_in_ruleRelationOp4024 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleShiftOp_in_ruleRelationOp4052 = new BitSet(new long[]{0x0000000400000002L});
+ public static final BitSet FOLLOW_ruleShiftOp_in_entryRuleShiftOp4090 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleShiftOp4100 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAdditiveOp_in_ruleShiftOp4147 = new BitSet(new long[]{0x0000000800000002L});
+ public static final BitSet FOLLOW_RULE_SHIFT_in_ruleShiftOp4193 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleAdditiveOp_in_ruleShiftOp4221 = new BitSet(new long[]{0x0000000800000002L});
+ public static final BitSet FOLLOW_ruleAdditiveOp_in_entryRuleAdditiveOp4259 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAdditiveOp4269 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleMathOp_in_ruleAdditiveOp4316 = new BitSet(new long[]{0x0000003000000002L});
+ public static final BitSet FOLLOW_RULE_PLUS_in_ruleAdditiveOp4379 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_RULE_MINUS_in_ruleAdditiveOp4399 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleMathOp_in_ruleAdditiveOp4430 = new BitSet(new long[]{0x0000003000000002L});
+ public static final BitSet FOLLOW_ruleMathOp_in_entryRuleMathOp4468 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleMathOp4478 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleUnaryOp_in_ruleMathOp4525 = new BitSet(new long[]{0x0000004000000002L});
+ public static final BitSet FOLLOW_RULE_MATH_in_ruleMathOp4571 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleUnaryOp_in_ruleMathOp4599 = new BitSet(new long[]{0x0000004000000002L});
+ public static final BitSet FOLLOW_ruleUnaryOp_in_entryRuleUnaryOp4637 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleUnaryOp4647 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNARY_in_ruleUnaryOp4685 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_RULE_PLUS_in_ruleUnaryOp4701 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_RULE_MINUS_in_ruleUnaryOp4717 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleUnaryOp4739 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PLUS_PLUS_in_ruleUnaryOp4758 = new BitSet(new long[]{0x1008200000000000L});
+ public static final BitSet FOLLOW_RULE_MINUS_MINUS_in_ruleUnaryOp4774 = new BitSet(new long[]{0x1008200000000000L});
+ public static final BitSet FOLLOW_ruleVariable_in_ruleUnaryOp4796 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleApplication_in_ruleUnaryOp4825 = new BitSet(new long[]{0x0000040000000002L});
+ public static final BitSet FOLLOW_RULE_QUESTION_in_ruleUnaryOp4836 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleApplication_in_entryRuleApplication4874 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleApplication4884 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_SUPER_in_ruleApplication4931 = new BitSet(new long[]{0x0000000000000102L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_ruleApplication4942 = new BitSet(new long[]{0x39382BB0420B6E60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleArgList_in_ruleApplication4962 = new BitSet(new long[]{0x0000000000000400L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_ruleApplication4973 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePrimaryExpression_in_ruleApplication5004 = new BitSet(new long[]{0x0003D00000000102L});
+ public static final BitSet FOLLOW_ruleFeatureCall_in_ruleApplication5025 = new BitSet(new long[]{0x0003D00000000102L});
+ public static final BitSet FOLLOW_ruleFeatureCall_in_entryRuleFeatureCall5063 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleFeatureCall5073 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleFunctionCall_in_ruleFeatureCall5120 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePropertyAccess_in_ruleFeatureCall5147 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleFunctionCall_in_entryRuleFunctionCall5182 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleFunctionCall5192 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FUNC_EXIST_in_ruleFunctionCall5238 = new BitSet(new long[]{0x0000000000000100L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_ruleFunctionCall5250 = new BitSet(new long[]{0x39382BB0420B6E60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleArgList_in_ruleFunctionCall5270 = new BitSet(new long[]{0x0000000000000400L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_ruleFunctionCall5281 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePropertyAccess_in_entryRulePropertyAccess5316 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRulePropertyAccess5326 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNamedPropertyAccess_in_rulePropertyAccess5373 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndexedPropertyAccess_in_rulePropertyAccess5400 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThisProperty_in_entryRuleThisProperty5435 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleThisProperty5445 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_AT_SIGIL_in_ruleThisProperty5481 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_ruleId_in_ruleThisProperty5502 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNamedPropertyAccess_in_entryRuleNamedPropertyAccess5537 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleNamedPropertyAccess5547 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_in_ruleNamedPropertyAccess5592 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_RULE_QUESTION_DOT_in_ruleNamedPropertyAccess5612 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_ruleId_in_ruleNamedPropertyAccess5641 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOUBLE_COLON_in_ruleNamedPropertyAccess5666 = new BitSet(new long[]{0x1000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleNamedPropertyAccess5692 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndexedPropertyAccess_in_entryRuleIndexedPropertyAccess5730 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIndexedPropertyAccess5740 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDEX_START_in_ruleIndexedPropertyAccess5776 = new BitSet(new long[]{0x39382BB00E0B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleIndex_in_ruleIndexedPropertyAccess5796 = new BitSet(new long[]{0x0004000000000000L});
+ public static final BitSet FOLLOW_RULE_INDEX_END_in_ruleIndexedPropertyAccess5807 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndex_in_entryRuleIndex5842 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIndex5852 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_DOT_in_ruleIndex5923 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleIndex5943 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleIndex5972 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleIndex6042 = new BitSet(new long[]{0x000000000C000000L});
+ public static final BitSet FOLLOW_RULE_DOT_DOT_in_ruleIndex6061 = new BitSet(new long[]{0x39382BB0020B6A62L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleIndex6081 = new BitSet(new long[]{0x39382BB0020B6A62L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleIndex6112 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleIndex6141 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePrimaryExpression_in_entryRulePrimaryExpression6177 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRulePrimaryExpression6187 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIfExp_in_rulePrimaryExpression6234 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParenthetical_in_rulePrimaryExpression6261 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLiteral_in_rulePrimaryExpression6288 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRange_in_rulePrimaryExpression6344 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArray_in_rulePrimaryExpression6378 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_rulePrimaryExpression6412 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLambda_in_rulePrimaryExpression6440 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThisProperty_in_rulePrimaryExpression6467 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_THIS_in_rulePrimaryExpression6493 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOR_in_rulePrimaryExpression6521 = new BitSet(new long[]{0x1000000000100000L});
+ public static final BitSet FOLLOW_ruleForBody_in_rulePrimaryExpression6541 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6562 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHILE_in_rulePrimaryExpression6592 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression6612 = new BitSet(new long[]{0x0000000040040000L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rulePrimaryExpression6624 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression6644 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6667 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNTIL_in_rulePrimaryExpression6697 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression6717 = new BitSet(new long[]{0x0000000040040000L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rulePrimaryExpression6729 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression6749 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6772 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LOOP_in_rulePrimaryExpression6802 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6822 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TRY_in_rulePrimaryExpression6852 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6872 = new BitSet(new long[]{0x00C0000000000002L});
+ public static final BitSet FOLLOW_RULE_CATCH_in_rulePrimaryExpression6885 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_ruleId_in_rulePrimaryExpression6905 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6926 = new BitSet(new long[]{0x0080000000000002L});
+ public static final BitSet FOLLOW_RULE_FINALLY_in_rulePrimaryExpression6938 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6958 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FINALLY_in_rulePrimaryExpression6979 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6999 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_SWITCH_in_rulePrimaryExpression7032 = new BitSet(new long[]{0x39382BB0420B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression7052 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rulePrimaryExpression7064 = new BitSet(new long[]{0x0600000080000000L});
+ public static final BitSet FOLLOW_ruleCase_in_rulePrimaryExpression7084 = new BitSet(new long[]{0x0600000080000000L});
+ public static final BitSet FOLLOW_RULE_ELSE_in_rulePrimaryExpression7097 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression7117 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rulePrimaryExpression7130 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_rulePrimaryExpression7159 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_entryRuleBlock7194 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleBlock7204 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleBlock7249 = new BitSet(new long[]{0x39382BB0820B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleBody_in_ruleBlock7271 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleBlock7283 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCase_in_entryRuleCase7318 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCase7328 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LEADING_WHEN_in_ruleCase7364 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleCase7384 = new BitSet(new long[]{0x0000000040200000L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleCase7396 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleCase7416 = new BitSet(new long[]{0x0000000040200000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleCase7439 = new BitSet(new long[]{0x0000000000000012L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleCase7451 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIfExp_in_entryRuleIfExp7488 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIfExp7498 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCondBlock_in_ruleIfExp7544 = new BitSet(new long[]{0x0200000000000002L});
+ public static final BitSet FOLLOW_RULE_ELSE_in_ruleIfExp7556 = new BitSet(new long[]{0x0800000000000000L});
+ public static final BitSet FOLLOW_ruleCondBlock_in_ruleIfExp7576 = new BitSet(new long[]{0x0200000000000002L});
+ public static final BitSet FOLLOW_RULE_ELSE_in_ruleIfExp7590 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleIfExp7610 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCondBlock_in_entryRuleCondBlock7648 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCondBlock7658 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_IF_in_ruleCondBlock7700 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleCondBlock7726 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleCondBlock7747 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_entryRuleIdRef7783 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIdRef7793 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_IDENTIFIER_in_ruleIdRef7837 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_entryRuleId7872 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleId7882 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_IDENTIFIER_in_ruleId7923 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_entryRuleProperty7963 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleProperty7973 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_ruleProperty8065 = new BitSet(new long[]{0x0001C00000000000L});
+ public static final BitSet FOLLOW_RULE_DOT_in_ruleProperty8083 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_RULE_DOUBLE_COLON_in_ruleProperty8103 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_RULE_QUESTION_DOT_in_ruleProperty8123 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_ruleId_in_ruleProperty8154 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_ruleProperty8195 = new BitSet(new long[]{0x0002000000000000L});
+ public static final BitSet FOLLOW_RULE_INDEX_START_in_ruleProperty8205 = new BitSet(new long[]{0x39382BB00E0B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleIndex_in_ruleProperty8227 = new BitSet(new long[]{0x0004000000000000L});
+ public static final BitSet FOLLOW_RULE_INDEX_END_in_ruleProperty8238 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleVariable_in_entryRuleVariable8274 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleVariable8284 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleVariable8331 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_AT_SIGIL_in_ruleVariable8349 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_RULE_THIS_in_ruleVariable8366 = new BitSet(new long[]{0x0000400000000000L});
+ public static final BitSet FOLLOW_RULE_DOT_in_ruleVariable8376 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_ruleId_in_ruleVariable8399 = new BitSet(new long[]{0x0000400000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_in_ruleVariable8410 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_ruleId_in_ruleVariable8430 = new BitSet(new long[]{0x0000400000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_ruleVariable8461 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArray_in_entryRuleAssignableArray8496 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignableArray8506 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_ruleAssignableArray8548 = new BitSet(new long[]{0x3008200002000000L});
+ public static final BitSet FOLLOW_ruleAssignableArgList_in_ruleAssignableArray8570 = new BitSet(new long[]{0x0000000010000000L});
+ public static final BitSet FOLLOW_RULE_RBRACKET_in_ruleAssignableArray8580 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArgList_in_entryRuleAssignableArgList8615 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignableArgList8625 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArg_in_ruleAssignableArgList8671 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleAssignableArgList8683 = new BitSet(new long[]{0x3008200002000000L});
+ public static final BitSet FOLLOW_ruleAssignableArg_in_ruleAssignableArgList8703 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_ruleAssignableArg_in_entryRuleAssignableArg8741 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignableArg8751 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_ruleAssignableArg8797 = new BitSet(new long[]{0x0000000008000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleAssignableArg8814 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_entryRuleAssignable8856 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignable8866 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleVariable_in_ruleAssignable8913 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_ruleAssignable8946 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArray_in_ruleAssignable8980 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArg_in_entryRuleArg9016 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArg9026 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleArg9072 = new BitSet(new long[]{0x0000000008000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleArg9089 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgLine_in_entryRuleArgLine9131 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArgLine9141 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArg_in_ruleArgLine9187 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleArgLine9199 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleArg_in_ruleArgLine9219 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleArgLine9233 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitArgList_in_entryRuleExplicitArgList9270 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleExplicitArgList9280 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgLine_in_ruleExplicitArgList9326 = new BitSet(new long[]{0x0000000040000012L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleExplicitArgList9339 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleArgLine_in_ruleExplicitArgList9359 = new BitSet(new long[]{0x0000000040000012L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleExplicitArgList9378 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleArgLine_in_ruleExplicitArgList9398 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleExplicitArgList9409 = new BitSet(new long[]{0x0000000040000012L});
+ public static final BitSet FOLLOW_ruleArgList_in_entryRuleArgList9447 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArgList9457 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitArgList_in_ruleArgList9513 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleArgList9531 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExplicitArgList_in_ruleArgList9551 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleArgList9562 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArray_in_entryRuleArray9600 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArray9610 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_ruleArray9652 = new BitSet(new long[]{0x39382BB0520B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleArgList_in_ruleArray9674 = new BitSet(new long[]{0x0000000010000000L});
+ public static final BitSet FOLLOW_RULE_RBRACKET_in_ruleArray9684 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_entryRuleDictionary9719 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictionary9729 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LCURLY_in_ruleDictionary9771 = new BitSet(new long[]{0x5000000040000200L,0x00000000000000F0L});
+ public static final BitSet FOLLOW_ruleDictItems_in_ruleDictionary9793 = new BitSet(new long[]{0x4000000000000000L});
+ public static final BitSet FOLLOW_RULE_RCURLY_in_ruleDictionary9803 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItems_in_entryRuleDictItems9838 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictItems9848 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitDictItems_in_ruleDictItems9904 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleDictItems9922 = new BitSet(new long[]{0x1000000000000200L,0x00000000000000F0L});
+ public static final BitSet FOLLOW_ruleExplicitDictItems_in_ruleDictItems9942 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleDictItems9953 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitDictItems_in_entryRuleExplicitDictItems9991 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleExplicitDictItems10001 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictLine_in_ruleExplicitDictItems10047 = new BitSet(new long[]{0x0000000040000012L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleExplicitDictItems10060 = new BitSet(new long[]{0x1000000000000200L,0x00000000000000F0L});
+ public static final BitSet FOLLOW_ruleDictLine_in_ruleExplicitDictItems10080 = new BitSet(new long[]{0x0000000040000012L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleExplicitDictItems10099 = new BitSet(new long[]{0x1000000000000200L,0x00000000000000F0L});
+ public static final BitSet FOLLOW_ruleDictLine_in_ruleExplicitDictItems10119 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleExplicitDictItems10130 = new BitSet(new long[]{0x0000000040000012L});
+ public static final BitSet FOLLOW_ruleDictLine_in_entryRuleDictLine10168 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictLine10178 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItem_in_ruleDictLine10224 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleDictLine10236 = new BitSet(new long[]{0x1000000000000200L,0x00000000000000F0L});
+ public static final BitSet FOLLOW_ruleDictItem_in_ruleDictLine10256 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleDictLine10270 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItem_in_entryRuleDictItem10307 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictItem10317 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictKey_in_ruleDictItem10372 = new BitSet(new long[]{0x8000000000000002L});
+ public static final BitSet FOLLOW_RULE_COLON_in_ruleDictItem10384 = new BitSet(new long[]{0x39382BB0420B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleDictItem10405 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleDictItem10423 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleDictItem10443 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleDictItem10454 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictKey_in_entryRuleDictKey10493 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictKey10503 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLiteral_in_ruleDictKey10550 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleDictKey10577 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLambda_in_entryRuleLambda10612 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLambda10622 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PARAM_START_in_ruleLambda10659 = new BitSet(new long[]{0x3000200002000000L,0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParam_in_ruleLambda10680 = new BitSet(new long[]{0x0000000000200000L,0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleLambda10692 = new BitSet(new long[]{0x3000200002000000L});
+ public static final BitSet FOLLOW_ruleParam_in_ruleLambda10712 = new BitSet(new long[]{0x0000000000200000L,0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PARAM_END_in_ruleLambda10727 = new BitSet(new long[]{0x0000000000000000L,0x000000000000000CL});
+ public static final BitSet FOLLOW_RULE_FUNC_ARROW_in_ruleLambda10740 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_RULE_BOUND_FUNC_ARROW_in_ruleLambda10756 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleLambda10777 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParam_in_entryRuleParam10813 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleParam10823 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleParam10871 = new BitSet(new long[]{0x0000000008000082L});
+ public static final BitSet FOLLOW_ruleArray_in_ruleParam10904 = new BitSet(new long[]{0x0000000008000082L});
+ public static final BitSet FOLLOW_ruleDictionary_in_ruleParam10938 = new BitSet(new long[]{0x0000000008000082L});
+ public static final BitSet FOLLOW_ruleThisProperty_in_ruleParam10966 = new BitSet(new long[]{0x0000000008000082L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleParam10984 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_ruleParam11007 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleParam11027 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNumberLiteral_in_entryRuleNumberLiteral11066 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleNumberLiteral11076 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_NUMBER_in_ruleNumberLiteral11121 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_entryRuleStringLiteral11156 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleStringLiteral11166 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_STRING_in_ruleStringLiteral11211 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBoolLiteral_in_entryRuleBoolLiteral11246 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleBoolLiteral11256 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BOOL_in_ruleBoolLiteral11301 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleJSLiteral_in_entryRuleJSLiteral11336 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleJSLiteral11346 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_JS_in_ruleJSLiteral11391 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRegexLiteral_in_entryRuleRegexLiteral11426 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRegexLiteral11436 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_REGEX_in_ruleRegexLiteral11481 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLiteral_in_entryRuleLiteral11516 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLiteral11526 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNumberLiteral_in_ruleLiteral11573 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_ruleLiteral11600 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBoolLiteral_in_ruleLiteral11627 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleJSLiteral_in_ruleLiteral11654 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRegexLiteral_in_ruleLiteral11681 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParenthetical_in_entryRuleParenthetical11716 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleParenthetical11726 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_ruleParenthetical11774 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleParenthetical11784 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleBody_in_ruleParenthetical11806 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleParenthetical11817 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
+ public static final BitSet FOLLOW_RULE_RPAREN_in_ruleParenthetical11827 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_ruleParenthetical11851 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleBody_in_ruleParenthetical11872 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
+ public static final BitSet FOLLOW_RULE_RPAREN_in_ruleParenthetical11883 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_synpred1_InternalCoffeeScript558 = new BitSet(new long[]{0x0000000000000080L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_synpred1_InternalCoffeeScript564 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
+ public static final BitSet FOLLOW_85_in_synpred1_InternalCoffeeScript566 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_POST_IF_in_synpred3_InternalCoffeeScript2039 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOR_in_synpred4_InternalCoffeeScript2094 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHILE_in_synpred5_InternalCoffeeScript2149 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred6_InternalCoffeeScript2197 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNTIL_in_synpred7_InternalCoffeeScript2245 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred8_InternalCoffeeScript2293 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOROF_in_synpred9_InternalCoffeeScript2668 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred10_InternalCoffeeScript2707 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FORIN_in_synpred11_InternalCoffeeScript2755 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred12_InternalCoffeeScript2795 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_synpred13_InternalCoffeeScript2834 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_synpred14_InternalCoffeeScript2882 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred15_InternalCoffeeScript2921 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_synpred17_InternalCoffeeScript3235 = new BitSet(new long[]{0x0000000020000080L});
+ public static final BitSet FOLLOW_set_in_synpred17_InternalCoffeeScript3244 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LOGIC_in_synpred18_InternalCoffeeScript3659 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMPARE_in_synpred19_InternalCoffeeScript3828 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RELATION_in_synpred20_InternalCoffeeScript3997 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_SHIFT_in_synpred21_InternalCoffeeScript4166 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_set_in_synpred22_InternalCoffeeScript4335 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_MATH_in_synpred23_InternalCoffeeScript4544 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_set_in_synpred24_InternalCoffeeScript5892 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_synpred25_InternalCoffeeScript5996 = new BitSet(new long[]{0x000000000C000000L});
+ public static final BitSet FOLLOW_set_in_synpred25_InternalCoffeeScript6005 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_synpred26_InternalCoffeeScript6306 = new BitSet(new long[]{0x39382BB0020B6A60L,0x00000000000001FDL});
+ public static final BitSet FOLLOW_ruleExpression_in_synpred26_InternalCoffeeScript6311 = new BitSet(new long[]{0x000000000C000000L});
+ public static final BitSet FOLLOW_set_in_synpred26_InternalCoffeeScript6316 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_synpred27_InternalCoffeeScript6362 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LCURLY_in_synpred28_InternalCoffeeScript6396 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_synpred29_InternalCoffeeScript8012 = new BitSet(new long[]{0x0001C00000000000L});
+ public static final BitSet FOLLOW_set_in_synpred29_InternalCoffeeScript8017 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_synpred30_InternalCoffeeScript8175 = new BitSet(new long[]{0x0002000000000000L});
+ public static final BitSet FOLLOW_RULE_INDEX_START_in_synpred30_InternalCoffeeScript8177 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LCURLY_in_synpred32_InternalCoffeeScript8930 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_synpred33_InternalCoffeeScript8964 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_synpred36_InternalCoffeeScript10888 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LCURLY_in_synpred37_InternalCoffeeScript10922 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_synpred38_InternalCoffeeScript11765 = new BitSet(new long[]{0x0000000040000000L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_synpred38_InternalCoffeeScript11767 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_synpred39_InternalCoffeeScript11846 = new BitSet(new long[]{0x0000000000000002L});
+
+}
\ No newline at end of file
diff --git a/csep/src-gen/csep/services/CoffeeScriptGrammarAccess.java b/csep/src-gen/csep/services/CoffeeScriptGrammarAccess.java
new file mode 100644
index 0000000..34bbaee
--- /dev/null
+++ b/csep/src-gen/csep/services/CoffeeScriptGrammarAccess.java
@@ -0,0 +1,4744 @@
+/*
+* generated by Xtext
+*/
+package csep.services;
+
+import com.google.inject.Singleton;
+import com.google.inject.Inject;
+
+import java.util.List;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.service.GrammarProvider;
+import org.eclipse.xtext.service.AbstractElementFinder.*;
+
+
+@Singleton
+public class CoffeeScriptGrammarAccess extends AbstractGrammarElementFinder {
+
+
+ public class RootElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Root");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cBodyParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final RuleCall cBlockParserRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0);
+ private final RuleCall cTERMINATORTerminalRuleCall_1_1 = (RuleCall)cGroup_1.eContents().get(1);
+
+ //Root:
+ // (Body | Block TERMINATOR)?;
+ public ParserRule getRule() { return rule; }
+
+ //(Body | Block TERMINATOR)?
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //Body
+ public RuleCall getBodyParserRuleCall_0() { return cBodyParserRuleCall_0; }
+
+ //Block TERMINATOR
+ public Group getGroup_1() { return cGroup_1; }
+
+ //Block
+ public RuleCall getBlockParserRuleCall_1_0() { return cBlockParserRuleCall_1_0; }
+
+ //TERMINATOR
+ public RuleCall getTERMINATORTerminalRuleCall_1_1() { return cTERMINATORTerminalRuleCall_1_1; }
+ }
+
+ public class BodyElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Body");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cLinesAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cLinesLineParserRuleCall_0_0 = (RuleCall)cLinesAssignment_0.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final RuleCall cTERMINATORTerminalRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0);
+ private final Assignment cLinesAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cLinesLineParserRuleCall_1_1_0 = (RuleCall)cLinesAssignment_1_1.eContents().get(0);
+
+ //Body:
+ // lines+=Line (TERMINATOR lines+=Line?)*;
+ public ParserRule getRule() { return rule; }
+
+ //lines+=Line (TERMINATOR lines+=Line?)*
+ public Group getGroup() { return cGroup; }
+
+ //lines+=Line
+ public Assignment getLinesAssignment_0() { return cLinesAssignment_0; }
+
+ //Line
+ public RuleCall getLinesLineParserRuleCall_0_0() { return cLinesLineParserRuleCall_0_0; }
+
+ //(TERMINATOR lines+=Line?)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //TERMINATOR
+ public RuleCall getTERMINATORTerminalRuleCall_1_0() { return cTERMINATORTerminalRuleCall_1_0; }
+
+ //lines+=Line?
+ public Assignment getLinesAssignment_1_1() { return cLinesAssignment_1_1; }
+
+ //Line
+ public RuleCall getLinesLineParserRuleCall_1_1_0() { return cLinesLineParserRuleCall_1_1_0; }
+ }
+
+ public class LineElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Line");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cStmtParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cExpressionParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+
+ //Line:
+ // Stmt | Expression;
+ public ParserRule getRule() { return rule; }
+
+ //Stmt | Expression
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //Stmt
+ public RuleCall getStmtParserRuleCall_0() { return cStmtParserRuleCall_0; }
+
+ //Expression
+ public RuleCall getExpressionParserRuleCall_1() { return cExpressionParserRuleCall_1; }
+ }
+
+ public class StmtElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Stmt");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cReturnStmtParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cThrowStmtParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+ private final RuleCall cRequireStmtParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+ private final RuleCall cCommentParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3);
+ private final RuleCall cClassDeclarationParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4);
+ private final Assignment cStatementAssignment_5 = (Assignment)cAlternatives.eContents().get(5);
+ private final RuleCall cStatementSTATEMENTTerminalRuleCall_5_0 = (RuleCall)cStatementAssignment_5.eContents().get(0);
+
+ //Stmt:
+ // ReturnStmt | ThrowStmt | RequireStmt | Comment | ClassDeclaration | statement=STATEMENT;
+ public ParserRule getRule() { return rule; }
+
+ //ReturnStmt | ThrowStmt | RequireStmt | Comment | ClassDeclaration | statement=STATEMENT
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //ReturnStmt
+ public RuleCall getReturnStmtParserRuleCall_0() { return cReturnStmtParserRuleCall_0; }
+
+ //ThrowStmt
+ public RuleCall getThrowStmtParserRuleCall_1() { return cThrowStmtParserRuleCall_1; }
+
+ //RequireStmt
+ public RuleCall getRequireStmtParserRuleCall_2() { return cRequireStmtParserRuleCall_2; }
+
+ //Comment
+ public RuleCall getCommentParserRuleCall_3() { return cCommentParserRuleCall_3; }
+
+ //ClassDeclaration
+ public RuleCall getClassDeclarationParserRuleCall_4() { return cClassDeclarationParserRuleCall_4; }
+
+ //statement=STATEMENT
+ public Assignment getStatementAssignment_5() { return cStatementAssignment_5; }
+
+ //STATEMENT
+ public RuleCall getStatementSTATEMENTTerminalRuleCall_5_0() { return cStatementSTATEMENTTerminalRuleCall_5_0; }
+ }
+
+ public class CommentElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Comment");
+ private final Assignment cCommentAssignment = (Assignment)rule.eContents().get(1);
+ private final RuleCall cCommentHERECOMMENTTerminalRuleCall_0 = (RuleCall)cCommentAssignment.eContents().get(0);
+
+ //Comment:
+ // comment=HERECOMMENT;
+ public ParserRule getRule() { return rule; }
+
+ //comment=HERECOMMENT
+ public Assignment getCommentAssignment() { return cCommentAssignment; }
+
+ //HERECOMMENT
+ public RuleCall getCommentHERECOMMENTTerminalRuleCall_0() { return cCommentHERECOMMENTTerminalRuleCall_0; }
+ }
+
+ public class RequireStmtElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RequireStmt");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cGroup.eContents().get(0);
+ private final Group cGroup_0_0 = (Group)cGroup_0.eContents().get(0);
+ private final Assignment cImportedNamespaceAssignment_0_0_0 = (Assignment)cGroup_0_0.eContents().get(0);
+ private final RuleCall cImportedNamespaceIdParserRuleCall_0_0_0_0 = (RuleCall)cImportedNamespaceAssignment_0_0_0.eContents().get(0);
+ private final RuleCall cEQUALTerminalRuleCall_0_0_1 = (RuleCall)cGroup_0_0.eContents().get(1);
+ private final Keyword cRequireKeyword_0_0_2 = (Keyword)cGroup_0_0.eContents().get(2);
+ private final RuleCall cCALL_STARTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final Assignment cUriAssignment_2 = (Assignment)cGroup.eContents().get(2);
+ private final RuleCall cUriSTRINGTerminalRuleCall_2_0 = (RuleCall)cUriAssignment_2.eContents().get(0);
+ private final RuleCall cCALL_ENDTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3);
+
+ /// **
+ // * Treat it a special way, because it takes care of import
+ // * / RequireStmt:
+ // => (importedNamespace=Id EQUAL "require") CALL_START uri=STRING CALL_END;
+ public ParserRule getRule() { return rule; }
+
+ //=> (importedNamespace=Id EQUAL "require") CALL_START uri=STRING CALL_END
+ public Group getGroup() { return cGroup; }
+
+ //=> (importedNamespace=Id EQUAL "require")
+ public Group getGroup_0() { return cGroup_0; }
+
+ //importedNamespace=Id EQUAL "require"
+ public Group getGroup_0_0() { return cGroup_0_0; }
+
+ //importedNamespace=Id
+ public Assignment getImportedNamespaceAssignment_0_0_0() { return cImportedNamespaceAssignment_0_0_0; }
+
+ //Id
+ public RuleCall getImportedNamespaceIdParserRuleCall_0_0_0_0() { return cImportedNamespaceIdParserRuleCall_0_0_0_0; }
+
+ //EQUAL
+ public RuleCall getEQUALTerminalRuleCall_0_0_1() { return cEQUALTerminalRuleCall_0_0_1; }
+
+ //"require"
+ public Keyword getRequireKeyword_0_0_2() { return cRequireKeyword_0_0_2; }
+
+ //CALL_START
+ public RuleCall getCALL_STARTTerminalRuleCall_1() { return cCALL_STARTTerminalRuleCall_1; }
+
+ //uri=STRING
+ public Assignment getUriAssignment_2() { return cUriAssignment_2; }
+
+ //STRING
+ public RuleCall getUriSTRINGTerminalRuleCall_2_0() { return cUriSTRINGTerminalRuleCall_2_0; }
+
+ //CALL_END
+ public RuleCall getCALL_ENDTerminalRuleCall_3() { return cCALL_ENDTerminalRuleCall_3; }
+ }
+
+ public class ReturnStmtElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ReturnStmt");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cReturnStmtAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cRETURNTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final Assignment cExpressionAssignment_2 = (Assignment)cGroup.eContents().get(2);
+ private final RuleCall cExpressionExpressionParserRuleCall_2_0 = (RuleCall)cExpressionAssignment_2.eContents().get(0);
+ private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
+ private final RuleCall cPOST_IFTerminalRuleCall_3_0 = (RuleCall)cGroup_3.eContents().get(0);
+ private final Assignment cConditionAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1);
+ private final RuleCall cConditionExpressionParserRuleCall_3_1_0 = (RuleCall)cConditionAssignment_3_1.eContents().get(0);
+
+ //ReturnStmt:
+ // {ReturnStmt} RETURN expression=Expression? (POST_IF condition=Expression)?;
+ public ParserRule getRule() { return rule; }
+
+ //{ReturnStmt} RETURN expression=Expression? (POST_IF condition=Expression)?
+ public Group getGroup() { return cGroup; }
+
+ //{ReturnStmt}
+ public Action getReturnStmtAction_0() { return cReturnStmtAction_0; }
+
+ //RETURN
+ public RuleCall getRETURNTerminalRuleCall_1() { return cRETURNTerminalRuleCall_1; }
+
+ //expression=Expression?
+ public Assignment getExpressionAssignment_2() { return cExpressionAssignment_2; }
+
+ //Expression
+ public RuleCall getExpressionExpressionParserRuleCall_2_0() { return cExpressionExpressionParserRuleCall_2_0; }
+
+ //(POST_IF condition=Expression)?
+ public Group getGroup_3() { return cGroup_3; }
+
+ //POST_IF
+ public RuleCall getPOST_IFTerminalRuleCall_3_0() { return cPOST_IFTerminalRuleCall_3_0; }
+
+ //condition=Expression
+ public Assignment getConditionAssignment_3_1() { return cConditionAssignment_3_1; }
+
+ //Expression
+ public RuleCall getConditionExpressionParserRuleCall_3_1_0() { return cConditionExpressionParserRuleCall_3_1_0; }
+ }
+
+ public class ThrowStmtElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ThrowStmt");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cTHROWTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Assignment cExpAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cExpExpressionParserRuleCall_1_0 = (RuleCall)cExpAssignment_1.eContents().get(0);
+
+ //ThrowStmt:
+ // THROW exp=Expression;
+ public ParserRule getRule() { return rule; }
+
+ //THROW exp=Expression
+ public Group getGroup() { return cGroup; }
+
+ //THROW
+ public RuleCall getTHROWTerminalRuleCall_0() { return cTHROWTerminalRuleCall_0; }
+
+ //exp=Expression
+ public Assignment getExpAssignment_1() { return cExpAssignment_1; }
+
+ //Expression
+ public RuleCall getExpExpressionParserRuleCall_1_0() { return cExpExpressionParserRuleCall_1_0; }
+ }
+
+ public class SuperClassElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "SuperClass");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cIdRefParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cPropertyParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+
+ /// **
+ // * Coffeescript is permissive, it can be any expression, but we want to be able to check it as crossref
+ // * / SuperClass:
+ // IdRef | Property;
+ public ParserRule getRule() { return rule; }
+
+ //IdRef | Property
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //IdRef
+ public RuleCall getIdRefParserRuleCall_0() { return cIdRefParserRuleCall_0; }
+
+ //Property
+ public RuleCall getPropertyParserRuleCall_1() { return cPropertyParserRuleCall_1; }
+ }
+
+ public class ClassDeclarationElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ClassDeclaration");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cClassDeclarationAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cCLASSTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2);
+ private final Assignment cBodyAssignment_2_0 = (Assignment)cAlternatives_2.eContents().get(0);
+ private final RuleCall cBodyBlockParserRuleCall_2_0_0 = (RuleCall)cBodyAssignment_2_0.eContents().get(0);
+ private final Group cGroup_2_1 = (Group)cAlternatives_2.eContents().get(1);
+ private final RuleCall cEXTENDSTerminalRuleCall_2_1_0 = (RuleCall)cGroup_2_1.eContents().get(0);
+ private final Assignment cExtendAssignment_2_1_1 = (Assignment)cGroup_2_1.eContents().get(1);
+ private final RuleCall cExtendSuperClassParserRuleCall_2_1_1_0 = (RuleCall)cExtendAssignment_2_1_1.eContents().get(0);
+ private final Assignment cBodyAssignment_2_1_2 = (Assignment)cGroup_2_1.eContents().get(2);
+ private final RuleCall cBodyBlockParserRuleCall_2_1_2_0 = (RuleCall)cBodyAssignment_2_1_2.eContents().get(0);
+ private final Group cGroup_2_2 = (Group)cAlternatives_2.eContents().get(2);
+ private final Assignment cNameAssignment_2_2_0 = (Assignment)cGroup_2_2.eContents().get(0);
+ private final Alternatives cNameAlternatives_2_2_0_0 = (Alternatives)cNameAssignment_2_2_0.eContents().get(0);
+ private final RuleCall cNameIdParserRuleCall_2_2_0_0_0 = (RuleCall)cNameAlternatives_2_2_0_0.eContents().get(0);
+ private final RuleCall cNamePropertyParserRuleCall_2_2_0_0_1 = (RuleCall)cNameAlternatives_2_2_0_0.eContents().get(1);
+ private final Group cGroup_2_2_1 = (Group)cGroup_2_2.eContents().get(1);
+ private final RuleCall cEXTENDSTerminalRuleCall_2_2_1_0 = (RuleCall)cGroup_2_2_1.eContents().get(0);
+ private final Assignment cExtendAssignment_2_2_1_1 = (Assignment)cGroup_2_2_1.eContents().get(1);
+ private final RuleCall cExtendSuperClassParserRuleCall_2_2_1_1_0 = (RuleCall)cExtendAssignment_2_2_1_1.eContents().get(0);
+ private final Assignment cBodyAssignment_2_2_2 = (Assignment)cGroup_2_2.eContents().get(2);
+ private final RuleCall cBodyBlockParserRuleCall_2_2_2_0 = (RuleCall)cBodyAssignment_2_2_2.eContents().get(0);
+
+ //ClassDeclaration:
+ // {ClassDeclaration} CLASS (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS
+ // extend=SuperClass)? body=Block)?;
+ public ParserRule getRule() { return rule; }
+
+ //{ClassDeclaration} CLASS (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS
+ //extend=SuperClass)? body=Block)?
+ public Group getGroup() { return cGroup; }
+
+ //{ClassDeclaration}
+ public Action getClassDeclarationAction_0() { return cClassDeclarationAction_0; }
+
+ //CLASS
+ public RuleCall getCLASSTerminalRuleCall_1() { return cCLASSTerminalRuleCall_1; }
+
+ //(body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block)?
+ public Alternatives getAlternatives_2() { return cAlternatives_2; }
+
+ //body=Block
+ public Assignment getBodyAssignment_2_0() { return cBodyAssignment_2_0; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_2_0_0() { return cBodyBlockParserRuleCall_2_0_0; }
+
+ //EXTENDS extend=SuperClass body=Block?
+ public Group getGroup_2_1() { return cGroup_2_1; }
+
+ //EXTENDS
+ public RuleCall getEXTENDSTerminalRuleCall_2_1_0() { return cEXTENDSTerminalRuleCall_2_1_0; }
+
+ //extend=SuperClass
+ public Assignment getExtendAssignment_2_1_1() { return cExtendAssignment_2_1_1; }
+
+ //SuperClass
+ public RuleCall getExtendSuperClassParserRuleCall_2_1_1_0() { return cExtendSuperClassParserRuleCall_2_1_1_0; }
+
+ //body=Block?
+ public Assignment getBodyAssignment_2_1_2() { return cBodyAssignment_2_1_2; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_2_1_2_0() { return cBodyBlockParserRuleCall_2_1_2_0; }
+
+ //name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block
+ public Group getGroup_2_2() { return cGroup_2_2; }
+
+ //name=(Id | Property)
+ public Assignment getNameAssignment_2_2_0() { return cNameAssignment_2_2_0; }
+
+ //Id | Property
+ public Alternatives getNameAlternatives_2_2_0_0() { return cNameAlternatives_2_2_0_0; }
+
+ //Id
+ public RuleCall getNameIdParserRuleCall_2_2_0_0_0() { return cNameIdParserRuleCall_2_2_0_0_0; }
+
+ //Property
+ public RuleCall getNamePropertyParserRuleCall_2_2_0_0_1() { return cNamePropertyParserRuleCall_2_2_0_0_1; }
+
+ //(EXTENDS extend=SuperClass)?
+ public Group getGroup_2_2_1() { return cGroup_2_2_1; }
+
+ //EXTENDS
+ public RuleCall getEXTENDSTerminalRuleCall_2_2_1_0() { return cEXTENDSTerminalRuleCall_2_2_1_0; }
+
+ //extend=SuperClass
+ public Assignment getExtendAssignment_2_2_1_1() { return cExtendAssignment_2_2_1_1; }
+
+ //SuperClass
+ public RuleCall getExtendSuperClassParserRuleCall_2_2_1_1_0() { return cExtendSuperClassParserRuleCall_2_2_1_1_0; }
+
+ //body=Block
+ public Assignment getBodyAssignment_2_2_2() { return cBodyAssignment_2_2_2; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_2_2_2_0() { return cBodyBlockParserRuleCall_2_2_2_0; }
+ }
+
+ public class AssignedClassDeclarationElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "AssignedClassDeclaration");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cClassDeclarationAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cCLASSTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2);
+ private final Group cGroup_2_0 = (Group)cAlternatives_2.eContents().get(0);
+ private final RuleCall cEXTENDSTerminalRuleCall_2_0_0 = (RuleCall)cGroup_2_0.eContents().get(0);
+ private final Assignment cExtendAssignment_2_0_1 = (Assignment)cGroup_2_0.eContents().get(1);
+ private final RuleCall cExtendSuperClassParserRuleCall_2_0_1_0 = (RuleCall)cExtendAssignment_2_0_1.eContents().get(0);
+ private final Assignment cBodyAssignment_2_0_2 = (Assignment)cGroup_2_0.eContents().get(2);
+ private final RuleCall cBodyBlockParserRuleCall_2_0_2_0 = (RuleCall)cBodyAssignment_2_0_2.eContents().get(0);
+ private final Group cGroup_2_1 = (Group)cAlternatives_2.eContents().get(1);
+ private final Assignment cNameAssignment_2_1_0 = (Assignment)cGroup_2_1.eContents().get(0);
+ private final Alternatives cNameAlternatives_2_1_0_0 = (Alternatives)cNameAssignment_2_1_0.eContents().get(0);
+ private final RuleCall cNameIdParserRuleCall_2_1_0_0_0 = (RuleCall)cNameAlternatives_2_1_0_0.eContents().get(0);
+ private final RuleCall cNamePropertyParserRuleCall_2_1_0_0_1 = (RuleCall)cNameAlternatives_2_1_0_0.eContents().get(1);
+ private final Group cGroup_2_1_1 = (Group)cGroup_2_1.eContents().get(1);
+ private final RuleCall cEXTENDSTerminalRuleCall_2_1_1_0 = (RuleCall)cGroup_2_1_1.eContents().get(0);
+ private final Assignment cExtendAssignment_2_1_1_1 = (Assignment)cGroup_2_1_1.eContents().get(1);
+ private final RuleCall cExtendSuperClassParserRuleCall_2_1_1_1_0 = (RuleCall)cExtendAssignment_2_1_1_1.eContents().get(0);
+ private final Assignment cBodyAssignment_2_1_2 = (Assignment)cGroup_2_1.eContents().get(2);
+ private final RuleCall cBodyBlockParserRuleCall_2_1_2_0 = (RuleCall)cBodyAssignment_2_1_2.eContents().get(0);
+
+ /// **
+ // * FIXME: it should be the same as ClassDeclaration, but it would result in a non-LL decision,
+ // * so I just removed the problematic options (a class body and a name or a superclass is required).
+ // * / AssignedClassDeclaration:
+ // {ClassDeclaration} CLASS (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)?
+ // body=Block)?;
+ public ParserRule getRule() { return rule; }
+
+ //{ClassDeclaration} CLASS (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)?
+ //body=Block)?
+ public Group getGroup() { return cGroup; }
+
+ //{ClassDeclaration}
+ public Action getClassDeclarationAction_0() { return cClassDeclarationAction_0; }
+
+ //CLASS
+ public RuleCall getCLASSTerminalRuleCall_1() { return cCLASSTerminalRuleCall_1; }
+
+ //(EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block)?
+ public Alternatives getAlternatives_2() { return cAlternatives_2; }
+
+ //EXTENDS extend=SuperClass body=Block
+ public Group getGroup_2_0() { return cGroup_2_0; }
+
+ //EXTENDS
+ public RuleCall getEXTENDSTerminalRuleCall_2_0_0() { return cEXTENDSTerminalRuleCall_2_0_0; }
+
+ //extend=SuperClass
+ public Assignment getExtendAssignment_2_0_1() { return cExtendAssignment_2_0_1; }
+
+ //SuperClass
+ public RuleCall getExtendSuperClassParserRuleCall_2_0_1_0() { return cExtendSuperClassParserRuleCall_2_0_1_0; }
+
+ //body=Block
+ public Assignment getBodyAssignment_2_0_2() { return cBodyAssignment_2_0_2; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_2_0_2_0() { return cBodyBlockParserRuleCall_2_0_2_0; }
+
+ //name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block
+ public Group getGroup_2_1() { return cGroup_2_1; }
+
+ //name=(Id | Property)
+ public Assignment getNameAssignment_2_1_0() { return cNameAssignment_2_1_0; }
+
+ //Id | Property
+ public Alternatives getNameAlternatives_2_1_0_0() { return cNameAlternatives_2_1_0_0; }
+
+ //Id
+ public RuleCall getNameIdParserRuleCall_2_1_0_0_0() { return cNameIdParserRuleCall_2_1_0_0_0; }
+
+ //Property
+ public RuleCall getNamePropertyParserRuleCall_2_1_0_0_1() { return cNamePropertyParserRuleCall_2_1_0_0_1; }
+
+ //(EXTENDS extend=SuperClass)?
+ public Group getGroup_2_1_1() { return cGroup_2_1_1; }
+
+ //EXTENDS
+ public RuleCall getEXTENDSTerminalRuleCall_2_1_1_0() { return cEXTENDSTerminalRuleCall_2_1_1_0; }
+
+ //extend=SuperClass
+ public Assignment getExtendAssignment_2_1_1_1() { return cExtendAssignment_2_1_1_1; }
+
+ //SuperClass
+ public RuleCall getExtendSuperClassParserRuleCall_2_1_1_1_0() { return cExtendSuperClassParserRuleCall_2_1_1_1_0; }
+
+ //body=Block
+ public Assignment getBodyAssignment_2_1_2() { return cBodyAssignment_2_1_2; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_2_1_2_0() { return cBodyBlockParserRuleCall_2_1_2_0; }
+ }
+
+ public class ExpressionElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Expression");
+ private final RuleCall cPostfixParserRuleCall = (RuleCall)rule.eContents().get(1);
+
+ //Expression:
+ // Postfix;
+ public ParserRule getRule() { return rule; }
+
+ //Postfix
+ public RuleCall getPostfixParserRuleCall() { return cPostfixParserRuleCall; }
+ }
+
+ public class PostfixElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Postfix");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cAssignmentParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0);
+ private final RuleCall cPOST_IFTerminalRuleCall_1_0_0 = (RuleCall)cGroup_1_0.eContents().get(0);
+ private final Action cIfDummyAction_1_0_1 = (Action)cGroup_1_0.eContents().get(1);
+ private final Assignment cConditionAssignment_1_0_2 = (Assignment)cGroup_1_0.eContents().get(2);
+ private final RuleCall cConditionExpressionParserRuleCall_1_0_2_0 = (RuleCall)cConditionAssignment_1_0_2.eContents().get(0);
+ private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1);
+ private final RuleCall cFORTerminalRuleCall_1_1_0 = (RuleCall)cGroup_1_1.eContents().get(0);
+ private final Action cForDummyAction_1_1_1 = (Action)cGroup_1_1.eContents().get(1);
+ private final Assignment cBodyAssignment_1_1_2 = (Assignment)cGroup_1_1.eContents().get(2);
+ private final RuleCall cBodyForBodyParserRuleCall_1_1_2_0 = (RuleCall)cBodyAssignment_1_1_2.eContents().get(0);
+ private final Group cGroup_1_2 = (Group)cAlternatives_1.eContents().get(2);
+ private final RuleCall cWHILETerminalRuleCall_1_2_0 = (RuleCall)cGroup_1_2.eContents().get(0);
+ private final Action cWhileDummyAction_1_2_1 = (Action)cGroup_1_2.eContents().get(1);
+ private final Assignment cBodyAssignment_1_2_2 = (Assignment)cGroup_1_2.eContents().get(2);
+ private final RuleCall cBodyExpressionParserRuleCall_1_2_2_0 = (RuleCall)cBodyAssignment_1_2_2.eContents().get(0);
+ private final Group cGroup_1_2_3 = (Group)cGroup_1_2.eContents().get(3);
+ private final RuleCall cWHENTerminalRuleCall_1_2_3_0 = (RuleCall)cGroup_1_2_3.eContents().get(0);
+ private final Assignment cWhenAssignment_1_2_3_1 = (Assignment)cGroup_1_2_3.eContents().get(1);
+ private final RuleCall cWhenExpressionParserRuleCall_1_2_3_1_0 = (RuleCall)cWhenAssignment_1_2_3_1.eContents().get(0);
+ private final Group cGroup_1_3 = (Group)cAlternatives_1.eContents().get(3);
+ private final RuleCall cUNTILTerminalRuleCall_1_3_0 = (RuleCall)cGroup_1_3.eContents().get(0);
+ private final Action cUntilDummyAction_1_3_1 = (Action)cGroup_1_3.eContents().get(1);
+ private final Assignment cBodyAssignment_1_3_2 = (Assignment)cGroup_1_3.eContents().get(2);
+ private final RuleCall cBodyExpressionParserRuleCall_1_3_2_0 = (RuleCall)cBodyAssignment_1_3_2.eContents().get(0);
+ private final Group cGroup_1_3_3 = (Group)cGroup_1_3.eContents().get(3);
+ private final RuleCall cWHENTerminalRuleCall_1_3_3_0 = (RuleCall)cGroup_1_3_3.eContents().get(0);
+ private final Assignment cWhenAssignment_1_3_3_1 = (Assignment)cGroup_1_3_3.eContents().get(1);
+ private final RuleCall cWhenExpressionParserRuleCall_1_3_3_1_0 = (RuleCall)cWhenAssignment_1_3_3_1.eContents().get(0);
+
+ //// right-assoc
+ //// Note: the lexer seems to know it should give a POST_IF token here
+ //Postfix returns Expression: //Assignment postfix+=(PostfixIf | ForBody)?;
+ // Assignment (POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE
+ // {While.dummy=current} body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN
+ // when=Expression)?)?;
+ public ParserRule getRule() { return rule; }
+
+ ////Assignment postfix+=(PostfixIf | ForBody)?;
+ //Assignment (POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE
+ //{While.dummy=current} body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN
+ //when=Expression)?)?
+ public Group getGroup() { return cGroup; }
+
+ ////Assignment postfix+=(PostfixIf | ForBody)?;
+ //Assignment
+ public RuleCall getAssignmentParserRuleCall_0() { return cAssignmentParserRuleCall_0; }
+
+ //(=> POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE {While.dummy=current}
+ //body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN when=Expression)?)?
+ public Alternatives getAlternatives_1() { return cAlternatives_1; }
+
+ //=> POST_IF {If.dummy=current} condition=Expression
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //=> POST_IF
+ public RuleCall getPOST_IFTerminalRuleCall_1_0_0() { return cPOST_IFTerminalRuleCall_1_0_0; }
+
+ //{If.dummy=current}
+ public Action getIfDummyAction_1_0_1() { return cIfDummyAction_1_0_1; }
+
+ //condition=Expression
+ public Assignment getConditionAssignment_1_0_2() { return cConditionAssignment_1_0_2; }
+
+ //Expression
+ public RuleCall getConditionExpressionParserRuleCall_1_0_2_0() { return cConditionExpressionParserRuleCall_1_0_2_0; }
+
+ //=> FOR {For.dummy=current} body=ForBody
+ public Group getGroup_1_1() { return cGroup_1_1; }
+
+ //=> FOR
+ public RuleCall getFORTerminalRuleCall_1_1_0() { return cFORTerminalRuleCall_1_1_0; }
+
+ //{For.dummy=current}
+ public Action getForDummyAction_1_1_1() { return cForDummyAction_1_1_1; }
+
+ //body=ForBody
+ public Assignment getBodyAssignment_1_1_2() { return cBodyAssignment_1_1_2; }
+
+ //ForBody
+ public RuleCall getBodyForBodyParserRuleCall_1_1_2_0() { return cBodyForBodyParserRuleCall_1_1_2_0; }
+
+ //=> WHILE {While.dummy=current} body=Expression (WHEN when=Expression)?
+ public Group getGroup_1_2() { return cGroup_1_2; }
+
+ //=> WHILE
+ public RuleCall getWHILETerminalRuleCall_1_2_0() { return cWHILETerminalRuleCall_1_2_0; }
+
+ //{While.dummy=current}
+ public Action getWhileDummyAction_1_2_1() { return cWhileDummyAction_1_2_1; }
+
+ //body=Expression
+ public Assignment getBodyAssignment_1_2_2() { return cBodyAssignment_1_2_2; }
+
+ //Expression
+ public RuleCall getBodyExpressionParserRuleCall_1_2_2_0() { return cBodyExpressionParserRuleCall_1_2_2_0; }
+
+ //(=> WHEN when=Expression)?
+ public Group getGroup_1_2_3() { return cGroup_1_2_3; }
+
+ //=> WHEN
+ public RuleCall getWHENTerminalRuleCall_1_2_3_0() { return cWHENTerminalRuleCall_1_2_3_0; }
+
+ //when=Expression
+ public Assignment getWhenAssignment_1_2_3_1() { return cWhenAssignment_1_2_3_1; }
+
+ //Expression
+ public RuleCall getWhenExpressionParserRuleCall_1_2_3_1_0() { return cWhenExpressionParserRuleCall_1_2_3_1_0; }
+
+ //=> UNTIL {Until.dummy=current} body=Expression (WHEN when=Expression)?
+ public Group getGroup_1_3() { return cGroup_1_3; }
+
+ //=> UNTIL
+ public RuleCall getUNTILTerminalRuleCall_1_3_0() { return cUNTILTerminalRuleCall_1_3_0; }
+
+ //{Until.dummy=current}
+ public Action getUntilDummyAction_1_3_1() { return cUntilDummyAction_1_3_1; }
+
+ //body=Expression
+ public Assignment getBodyAssignment_1_3_2() { return cBodyAssignment_1_3_2; }
+
+ //Expression
+ public RuleCall getBodyExpressionParserRuleCall_1_3_2_0() { return cBodyExpressionParserRuleCall_1_3_2_0; }
+
+ //(=> WHEN when=Expression)?
+ public Group getGroup_1_3_3() { return cGroup_1_3_3; }
+
+ //=> WHEN
+ public RuleCall getWHENTerminalRuleCall_1_3_3_0() { return cWHENTerminalRuleCall_1_3_3_0; }
+
+ //when=Expression
+ public Assignment getWhenAssignment_1_3_3_1() { return cWhenAssignment_1_3_3_1; }
+
+ //Expression
+ public RuleCall getWhenExpressionParserRuleCall_1_3_3_1_0() { return cWhenExpressionParserRuleCall_1_3_3_1_0; }
+ }
+
+ public class ForBodyElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ForBody");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cOWNTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Assignment cIndexesAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cIndexesForValueParserRuleCall_1_0 = (RuleCall)cIndexesAssignment_1.eContents().get(0);
+ private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
+ private final RuleCall cCOMMATerminalRuleCall_2_0 = (RuleCall)cGroup_2.eContents().get(0);
+ private final Assignment cIndexesAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1);
+ private final RuleCall cIndexesForValueParserRuleCall_2_1_0 = (RuleCall)cIndexesAssignment_2_1.eContents().get(0);
+ private final Assignment cSourceAssignment_3 = (Assignment)cGroup.eContents().get(3);
+ private final RuleCall cSourceForSourceParserRuleCall_3_0 = (RuleCall)cSourceAssignment_3.eContents().get(0);
+
+ //ForBody returns Expression: //FIXME: Range |
+ // OWN? indexes+=ForValue (COMMA indexes+=ForValue)* source=ForSource;
+ public ParserRule getRule() { return rule; }
+
+ ////FIXME: Range |
+ //OWN? indexes+=ForValue (COMMA indexes+=ForValue)* source=ForSource
+ public Group getGroup() { return cGroup; }
+
+ ////FIXME: Range |
+ //OWN?
+ public RuleCall getOWNTerminalRuleCall_0() { return cOWNTerminalRuleCall_0; }
+
+ //indexes+=ForValue
+ public Assignment getIndexesAssignment_1() { return cIndexesAssignment_1; }
+
+ //ForValue
+ public RuleCall getIndexesForValueParserRuleCall_1_0() { return cIndexesForValueParserRuleCall_1_0; }
+
+ //(COMMA indexes+=ForValue)*
+ public Group getGroup_2() { return cGroup_2; }
+
+ //COMMA
+ public RuleCall getCOMMATerminalRuleCall_2_0() { return cCOMMATerminalRuleCall_2_0; }
+
+ //indexes+=ForValue
+ public Assignment getIndexesAssignment_2_1() { return cIndexesAssignment_2_1; }
+
+ //ForValue
+ public RuleCall getIndexesForValueParserRuleCall_2_1_0() { return cIndexesForValueParserRuleCall_2_1_0; }
+
+ //source=ForSource
+ public Assignment getSourceAssignment_3() { return cSourceAssignment_3; }
+
+ //ForSource
+ public RuleCall getSourceForSourceParserRuleCall_3_0() { return cSourceForSourceParserRuleCall_3_0; }
+ }
+
+ public class ForValueElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ForValue");
+ private final RuleCall cIdParserRuleCall = (RuleCall)rule.eContents().get(1);
+
+ ////FIXME | Array | Dictionary;
+ //ForValue:
+ // Id;
+ public ParserRule getRule() { return rule; }
+
+ //Id
+ public RuleCall getIdParserRuleCall() { return cIdParserRuleCall; }
+ }
+
+ public class ForSourceElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ForSource");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cForSourceAction_0 = (Action)cGroup.eContents().get(0);
+ private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0);
+ private final RuleCall cFOROFTerminalRuleCall_1_0_0 = (RuleCall)cGroup_1_0.eContents().get(0);
+ private final Assignment cSourceAssignment_1_0_1 = (Assignment)cGroup_1_0.eContents().get(1);
+ private final RuleCall cSourceExpressionParserRuleCall_1_0_1_0 = (RuleCall)cSourceAssignment_1_0_1.eContents().get(0);
+ private final Group cGroup_1_0_2 = (Group)cGroup_1_0.eContents().get(2);
+ private final RuleCall cWHENTerminalRuleCall_1_0_2_0 = (RuleCall)cGroup_1_0_2.eContents().get(0);
+ private final Assignment cWhenAssignment_1_0_2_1 = (Assignment)cGroup_1_0_2.eContents().get(1);
+ private final RuleCall cWhenExpressionParserRuleCall_1_0_2_1_0 = (RuleCall)cWhenAssignment_1_0_2_1.eContents().get(0);
+ private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1);
+ private final RuleCall cFORINTerminalRuleCall_1_1_0 = (RuleCall)cGroup_1_1.eContents().get(0);
+ private final Assignment cSourceAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1);
+ private final RuleCall cSourceExpressionParserRuleCall_1_1_1_0 = (RuleCall)cSourceAssignment_1_1_1.eContents().get(0);
+ private final Alternatives cAlternatives_1_1_2 = (Alternatives)cGroup_1_1.eContents().get(2);
+ private final Group cGroup_1_1_2_0 = (Group)cAlternatives_1_1_2.eContents().get(0);
+ private final RuleCall cWHENTerminalRuleCall_1_1_2_0_0 = (RuleCall)cGroup_1_1_2_0.eContents().get(0);
+ private final Assignment cWhenAssignment_1_1_2_0_1 = (Assignment)cGroup_1_1_2_0.eContents().get(1);
+ private final RuleCall cWhenExpressionParserRuleCall_1_1_2_0_1_0 = (RuleCall)cWhenAssignment_1_1_2_0_1.eContents().get(0);
+ private final Group cGroup_1_1_2_0_2 = (Group)cGroup_1_1_2_0.eContents().get(2);
+ private final RuleCall cBYTerminalRuleCall_1_1_2_0_2_0 = (RuleCall)cGroup_1_1_2_0_2.eContents().get(0);
+ private final Assignment cByAssignment_1_1_2_0_2_1 = (Assignment)cGroup_1_1_2_0_2.eContents().get(1);
+ private final RuleCall cByExpressionParserRuleCall_1_1_2_0_2_1_0 = (RuleCall)cByAssignment_1_1_2_0_2_1.eContents().get(0);
+ private final Group cGroup_1_1_2_1 = (Group)cAlternatives_1_1_2.eContents().get(1);
+ private final RuleCall cBYTerminalRuleCall_1_1_2_1_0 = (RuleCall)cGroup_1_1_2_1.eContents().get(0);
+ private final Assignment cByAssignment_1_1_2_1_1 = (Assignment)cGroup_1_1_2_1.eContents().get(1);
+ private final RuleCall cByExpressionParserRuleCall_1_1_2_1_1_0 = (RuleCall)cByAssignment_1_1_2_1_1.eContents().get(0);
+ private final Group cGroup_1_1_2_1_2 = (Group)cGroup_1_1_2_1.eContents().get(2);
+ private final RuleCall cWHENTerminalRuleCall_1_1_2_1_2_0 = (RuleCall)cGroup_1_1_2_1_2.eContents().get(0);
+ private final Assignment cWhenAssignment_1_1_2_1_2_1 = (Assignment)cGroup_1_1_2_1_2.eContents().get(1);
+ private final RuleCall cWhenExpressionParserRuleCall_1_1_2_1_2_1_0 = (RuleCall)cWhenAssignment_1_1_2_1_2_1.eContents().get(0);
+
+ //ForSource:
+ // {ForSource} (FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY
+ // by=Expression)? | BY by=Expression (WHEN when=Expression)?)?);
+ public ParserRule getRule() { return rule; }
+
+ //{ForSource} (FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY
+ //by=Expression)? | BY by=Expression (WHEN when=Expression)?)?)
+ public Group getGroup() { return cGroup; }
+
+ //{ForSource}
+ public Action getForSourceAction_0() { return cForSourceAction_0; }
+
+ //=> FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY by=Expression)? |
+ //BY by=Expression (WHEN when=Expression)?)?
+ public Alternatives getAlternatives_1() { return cAlternatives_1; }
+
+ //=> FOROF source=Expression (WHEN when=Expression)?
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //=> FOROF
+ public RuleCall getFOROFTerminalRuleCall_1_0_0() { return cFOROFTerminalRuleCall_1_0_0; }
+
+ //source=Expression
+ public Assignment getSourceAssignment_1_0_1() { return cSourceAssignment_1_0_1; }
+
+ //Expression
+ public RuleCall getSourceExpressionParserRuleCall_1_0_1_0() { return cSourceExpressionParserRuleCall_1_0_1_0; }
+
+ //(=> WHEN when=Expression)?
+ public Group getGroup_1_0_2() { return cGroup_1_0_2; }
+
+ //=> WHEN
+ public RuleCall getWHENTerminalRuleCall_1_0_2_0() { return cWHENTerminalRuleCall_1_0_2_0; }
+
+ //when=Expression
+ public Assignment getWhenAssignment_1_0_2_1() { return cWhenAssignment_1_0_2_1; }
+
+ //Expression
+ public RuleCall getWhenExpressionParserRuleCall_1_0_2_1_0() { return cWhenExpressionParserRuleCall_1_0_2_1_0; }
+
+ //=> FORIN source=Expression (WHEN when=Expression (BY by=Expression)? | BY by=Expression (WHEN when=Expression)?)?
+ public Group getGroup_1_1() { return cGroup_1_1; }
+
+ //=> FORIN
+ public RuleCall getFORINTerminalRuleCall_1_1_0() { return cFORINTerminalRuleCall_1_1_0; }
+
+ //source=Expression
+ public Assignment getSourceAssignment_1_1_1() { return cSourceAssignment_1_1_1; }
+
+ //Expression
+ public RuleCall getSourceExpressionParserRuleCall_1_1_1_0() { return cSourceExpressionParserRuleCall_1_1_1_0; }
+
+ //(=> WHEN when=Expression (BY by=Expression)? | BY by=Expression (WHEN when=Expression)?)?
+ public Alternatives getAlternatives_1_1_2() { return cAlternatives_1_1_2; }
+
+ //=> WHEN when=Expression (BY by=Expression)?
+ public Group getGroup_1_1_2_0() { return cGroup_1_1_2_0; }
+
+ //=> WHEN
+ public RuleCall getWHENTerminalRuleCall_1_1_2_0_0() { return cWHENTerminalRuleCall_1_1_2_0_0; }
+
+ //when=Expression
+ public Assignment getWhenAssignment_1_1_2_0_1() { return cWhenAssignment_1_1_2_0_1; }
+
+ //Expression
+ public RuleCall getWhenExpressionParserRuleCall_1_1_2_0_1_0() { return cWhenExpressionParserRuleCall_1_1_2_0_1_0; }
+
+ //(=> BY by=Expression)?
+ public Group getGroup_1_1_2_0_2() { return cGroup_1_1_2_0_2; }
+
+ //=> BY
+ public RuleCall getBYTerminalRuleCall_1_1_2_0_2_0() { return cBYTerminalRuleCall_1_1_2_0_2_0; }
+
+ //by=Expression
+ public Assignment getByAssignment_1_1_2_0_2_1() { return cByAssignment_1_1_2_0_2_1; }
+
+ //Expression
+ public RuleCall getByExpressionParserRuleCall_1_1_2_0_2_1_0() { return cByExpressionParserRuleCall_1_1_2_0_2_1_0; }
+
+ //=> BY by=Expression (WHEN when=Expression)?
+ public Group getGroup_1_1_2_1() { return cGroup_1_1_2_1; }
+
+ //=> BY
+ public RuleCall getBYTerminalRuleCall_1_1_2_1_0() { return cBYTerminalRuleCall_1_1_2_1_0; }
+
+ //by=Expression
+ public Assignment getByAssignment_1_1_2_1_1() { return cByAssignment_1_1_2_1_1; }
+
+ //Expression
+ public RuleCall getByExpressionParserRuleCall_1_1_2_1_1_0() { return cByExpressionParserRuleCall_1_1_2_1_1_0; }
+
+ //(=> WHEN when=Expression)?
+ public Group getGroup_1_1_2_1_2() { return cGroup_1_1_2_1_2; }
+
+ //=> WHEN
+ public RuleCall getWHENTerminalRuleCall_1_1_2_1_2_0() { return cWHENTerminalRuleCall_1_1_2_1_2_0; }
+
+ //when=Expression
+ public Assignment getWhenAssignment_1_1_2_1_2_1() { return cWhenAssignment_1_1_2_1_2_1; }
+
+ //Expression
+ public RuleCall getWhenExpressionParserRuleCall_1_1_2_1_2_1_0() { return cWhenExpressionParserRuleCall_1_1_2_1_2_1_0; }
+ }
+
+ public class RangeElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Range");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cGroup.eContents().get(0);
+ private final Group cGroup_0_0 = (Group)cGroup_0.eContents().get(0);
+ private final RuleCall cLBRACKETTerminalRuleCall_0_0_0 = (RuleCall)cGroup_0_0.eContents().get(0);
+ private final Assignment cStartAssignment_0_0_1 = (Assignment)cGroup_0_0.eContents().get(1);
+ private final RuleCall cStartExpressionParserRuleCall_0_0_1_0 = (RuleCall)cStartAssignment_0_0_1.eContents().get(0);
+ private final Alternatives cAlternatives_0_0_2 = (Alternatives)cGroup_0_0.eContents().get(2);
+ private final RuleCall cDOT_DOTTerminalRuleCall_0_0_2_0 = (RuleCall)cAlternatives_0_0_2.eContents().get(0);
+ private final RuleCall cELLIPSISTerminalRuleCall_0_0_2_1 = (RuleCall)cAlternatives_0_0_2.eContents().get(1);
+ private final Assignment cEndAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cEndExpressionParserRuleCall_1_0 = (RuleCall)cEndAssignment_1.eContents().get(0);
+ private final RuleCall cRBRACKETTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2);
+
+ //Range:
+ // => (LBRACKET start=Expression (DOT_DOT | ELLIPSIS)) end=Expression RBRACKET;
+ public ParserRule getRule() { return rule; }
+
+ //=> (LBRACKET start=Expression (DOT_DOT | ELLIPSIS)) end=Expression RBRACKET
+ public Group getGroup() { return cGroup; }
+
+ //=> (LBRACKET start=Expression (DOT_DOT | ELLIPSIS))
+ public Group getGroup_0() { return cGroup_0; }
+
+ //LBRACKET start=Expression (DOT_DOT | ELLIPSIS)
+ public Group getGroup_0_0() { return cGroup_0_0; }
+
+ //LBRACKET
+ public RuleCall getLBRACKETTerminalRuleCall_0_0_0() { return cLBRACKETTerminalRuleCall_0_0_0; }
+
+ //start=Expression
+ public Assignment getStartAssignment_0_0_1() { return cStartAssignment_0_0_1; }
+
+ //Expression
+ public RuleCall getStartExpressionParserRuleCall_0_0_1_0() { return cStartExpressionParserRuleCall_0_0_1_0; }
+
+ //DOT_DOT | ELLIPSIS
+ public Alternatives getAlternatives_0_0_2() { return cAlternatives_0_0_2; }
+
+ //DOT_DOT
+ public RuleCall getDOT_DOTTerminalRuleCall_0_0_2_0() { return cDOT_DOTTerminalRuleCall_0_0_2_0; }
+
+ //ELLIPSIS
+ public RuleCall getELLIPSISTerminalRuleCall_0_0_2_1() { return cELLIPSISTerminalRuleCall_0_0_2_1; }
+
+ //end=Expression
+ public Assignment getEndAssignment_1() { return cEndAssignment_1; }
+
+ //Expression
+ public RuleCall getEndExpressionParserRuleCall_1_0() { return cEndExpressionParserRuleCall_1_0; }
+
+ //RBRACKET
+ public RuleCall getRBRACKETTerminalRuleCall_2() { return cRBRACKETTerminalRuleCall_2; }
+ }
+
+ public class AssignmentElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Assignment");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+ private final Group cGroup_0_0 = (Group)cGroup_0.eContents().get(0);
+ private final Group cGroup_0_0_0 = (Group)cGroup_0_0.eContents().get(0);
+ private final Assignment cLeftAssignment_0_0_0_0 = (Assignment)cGroup_0_0_0.eContents().get(0);
+ private final RuleCall cLeftAssignableParserRuleCall_0_0_0_0_0 = (RuleCall)cLeftAssignment_0_0_0_0.eContents().get(0);
+ private final Assignment cOperatorAssignment_0_0_0_1 = (Assignment)cGroup_0_0_0.eContents().get(1);
+ private final Alternatives cOperatorAlternatives_0_0_0_1_0 = (Alternatives)cOperatorAssignment_0_0_0_1.eContents().get(0);
+ private final RuleCall cOperatorEQUALTerminalRuleCall_0_0_0_1_0_0 = (RuleCall)cOperatorAlternatives_0_0_0_1_0.eContents().get(0);
+ private final RuleCall cOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1 = (RuleCall)cOperatorAlternatives_0_0_0_1_0.eContents().get(1);
+ private final Assignment cRightAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
+ private final RuleCall cRightAssignedParserRuleCall_0_1_0 = (RuleCall)cRightAssignment_0_1.eContents().get(0);
+ private final RuleCall cLogicOpParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+
+ //Assignment returns Expression:
+ // => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned | LogicOp;
+ public ParserRule getRule() { return rule; }
+
+ //=> (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned | LogicOp
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //=> (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned
+ public Group getGroup_0() { return cGroup_0; }
+
+ //=> (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN))
+ public Group getGroup_0_0() { return cGroup_0_0; }
+
+ //left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)
+ public Group getGroup_0_0_0() { return cGroup_0_0_0; }
+
+ //left=Assignable
+ public Assignment getLeftAssignment_0_0_0_0() { return cLeftAssignment_0_0_0_0; }
+
+ //Assignable
+ public RuleCall getLeftAssignableParserRuleCall_0_0_0_0_0() { return cLeftAssignableParserRuleCall_0_0_0_0_0; }
+
+ //operator=(EQUAL | COMPOUND_ASSIGN)
+ public Assignment getOperatorAssignment_0_0_0_1() { return cOperatorAssignment_0_0_0_1; }
+
+ //EQUAL | COMPOUND_ASSIGN
+ public Alternatives getOperatorAlternatives_0_0_0_1_0() { return cOperatorAlternatives_0_0_0_1_0; }
+
+ //EQUAL
+ public RuleCall getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0() { return cOperatorEQUALTerminalRuleCall_0_0_0_1_0_0; }
+
+ //COMPOUND_ASSIGN
+ public RuleCall getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1() { return cOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1; }
+
+ //right=Assigned
+ public Assignment getRightAssignment_0_1() { return cRightAssignment_0_1; }
+
+ //Assigned
+ public RuleCall getRightAssignedParserRuleCall_0_1_0() { return cRightAssignedParserRuleCall_0_1_0; }
+
+ //LogicOp
+ public RuleCall getLogicOpParserRuleCall_1() { return cLogicOpParserRuleCall_1; }
+ }
+
+ public class AssignedElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Assigned");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cExpressionParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final RuleCall cINDENTTerminalRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0);
+ private final RuleCall cExpressionParserRuleCall_1_1 = (RuleCall)cGroup_1.eContents().get(1);
+ private final RuleCall cOUTDENTTerminalRuleCall_1_2 = (RuleCall)cGroup_1.eContents().get(2);
+ private final RuleCall cAssignedClassDeclarationParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+
+ //Assigned returns Expression:
+ // Expression | INDENT Expression OUTDENT | AssignedClassDeclaration;
+ public ParserRule getRule() { return rule; }
+
+ //Expression | INDENT Expression OUTDENT | AssignedClassDeclaration
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //Expression
+ public RuleCall getExpressionParserRuleCall_0() { return cExpressionParserRuleCall_0; }
+
+ //INDENT Expression OUTDENT
+ public Group getGroup_1() { return cGroup_1; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_1_0() { return cINDENTTerminalRuleCall_1_0; }
+
+ //Expression
+ public RuleCall getExpressionParserRuleCall_1_1() { return cExpressionParserRuleCall_1_1; }
+
+ //OUTDENT
+ public RuleCall getOUTDENTTerminalRuleCall_1_2() { return cOUTDENTTerminalRuleCall_1_2; }
+
+ //AssignedClassDeclaration
+ public RuleCall getAssignedClassDeclarationParserRuleCall_2() { return cAssignedClassDeclarationParserRuleCall_2; }
+ }
+
+ public class LogicOpElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "LogicOp");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cCompareOpParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cGroup_1.eContents().get(0);
+ private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0);
+ private final Action cBinaryExpLeftAction_1_0_0_0 = (Action)cGroup_1_0_0.eContents().get(0);
+ private final Assignment cOperatorAssignment_1_0_0_1 = (Assignment)cGroup_1_0_0.eContents().get(1);
+ private final RuleCall cOperatorLOGICTerminalRuleCall_1_0_0_1_0 = (RuleCall)cOperatorAssignment_1_0_0_1.eContents().get(0);
+ private final Assignment cRightAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cRightCompareOpParserRuleCall_1_1_0 = (RuleCall)cRightAssignment_1_1.eContents().get(0);
+
+ //LogicOp returns Expression:
+ // CompareOp (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*;
+ public ParserRule getRule() { return rule; }
+
+ //CompareOp (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*
+ public Group getGroup() { return cGroup; }
+
+ //CompareOp
+ public RuleCall getCompareOpParserRuleCall_0() { return cCompareOpParserRuleCall_0; }
+
+ //(=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //=> ({BinaryExp.left=current} operator=LOGIC)
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //{BinaryExp.left=current} operator=LOGIC
+ public Group getGroup_1_0_0() { return cGroup_1_0_0; }
+
+ //{BinaryExp.left=current}
+ public Action getBinaryExpLeftAction_1_0_0_0() { return cBinaryExpLeftAction_1_0_0_0; }
+
+ //operator=LOGIC
+ public Assignment getOperatorAssignment_1_0_0_1() { return cOperatorAssignment_1_0_0_1; }
+
+ //LOGIC
+ public RuleCall getOperatorLOGICTerminalRuleCall_1_0_0_1_0() { return cOperatorLOGICTerminalRuleCall_1_0_0_1_0; }
+
+ //right=CompareOp
+ public Assignment getRightAssignment_1_1() { return cRightAssignment_1_1; }
+
+ //CompareOp
+ public RuleCall getRightCompareOpParserRuleCall_1_1_0() { return cRightCompareOpParserRuleCall_1_1_0; }
+ }
+
+ public class CompareOpElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "CompareOp");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cRelationOpParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cGroup_1.eContents().get(0);
+ private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0);
+ private final Action cBinaryExpLeftAction_1_0_0_0 = (Action)cGroup_1_0_0.eContents().get(0);
+ private final Assignment cOperatorAssignment_1_0_0_1 = (Assignment)cGroup_1_0_0.eContents().get(1);
+ private final RuleCall cOperatorCOMPARETerminalRuleCall_1_0_0_1_0 = (RuleCall)cOperatorAssignment_1_0_0_1.eContents().get(0);
+ private final Assignment cRightAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cRightRelationOpParserRuleCall_1_1_0 = (RuleCall)cRightAssignment_1_1.eContents().get(0);
+
+ //CompareOp returns Expression:
+ // RelationOp (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*;
+ public ParserRule getRule() { return rule; }
+
+ //RelationOp (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*
+ public Group getGroup() { return cGroup; }
+
+ //RelationOp
+ public RuleCall getRelationOpParserRuleCall_0() { return cRelationOpParserRuleCall_0; }
+
+ //(=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //=> ({BinaryExp.left=current} operator=COMPARE)
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //{BinaryExp.left=current} operator=COMPARE
+ public Group getGroup_1_0_0() { return cGroup_1_0_0; }
+
+ //{BinaryExp.left=current}
+ public Action getBinaryExpLeftAction_1_0_0_0() { return cBinaryExpLeftAction_1_0_0_0; }
+
+ //operator=COMPARE
+ public Assignment getOperatorAssignment_1_0_0_1() { return cOperatorAssignment_1_0_0_1; }
+
+ //COMPARE
+ public RuleCall getOperatorCOMPARETerminalRuleCall_1_0_0_1_0() { return cOperatorCOMPARETerminalRuleCall_1_0_0_1_0; }
+
+ //right=RelationOp
+ public Assignment getRightAssignment_1_1() { return cRightAssignment_1_1; }
+
+ //RelationOp
+ public RuleCall getRightRelationOpParserRuleCall_1_1_0() { return cRightRelationOpParserRuleCall_1_1_0; }
+ }
+
+ public class RelationOpElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RelationOp");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cShiftOpParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cGroup_1.eContents().get(0);
+ private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0);
+ private final Action cBinaryExpLeftAction_1_0_0_0 = (Action)cGroup_1_0_0.eContents().get(0);
+ private final Assignment cOperatorAssignment_1_0_0_1 = (Assignment)cGroup_1_0_0.eContents().get(1);
+ private final RuleCall cOperatorRELATIONTerminalRuleCall_1_0_0_1_0 = (RuleCall)cOperatorAssignment_1_0_0_1.eContents().get(0);
+ private final Assignment cRightAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cRightShiftOpParserRuleCall_1_1_0 = (RuleCall)cRightAssignment_1_1.eContents().get(0);
+
+ //RelationOp returns Expression:
+ // ShiftOp (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*;
+ public ParserRule getRule() { return rule; }
+
+ //ShiftOp (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*
+ public Group getGroup() { return cGroup; }
+
+ //ShiftOp
+ public RuleCall getShiftOpParserRuleCall_0() { return cShiftOpParserRuleCall_0; }
+
+ //(=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //=> ({BinaryExp.left=current} operator=RELATION)
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //{BinaryExp.left=current} operator=RELATION
+ public Group getGroup_1_0_0() { return cGroup_1_0_0; }
+
+ //{BinaryExp.left=current}
+ public Action getBinaryExpLeftAction_1_0_0_0() { return cBinaryExpLeftAction_1_0_0_0; }
+
+ //operator=RELATION
+ public Assignment getOperatorAssignment_1_0_0_1() { return cOperatorAssignment_1_0_0_1; }
+
+ //RELATION
+ public RuleCall getOperatorRELATIONTerminalRuleCall_1_0_0_1_0() { return cOperatorRELATIONTerminalRuleCall_1_0_0_1_0; }
+
+ //right=ShiftOp
+ public Assignment getRightAssignment_1_1() { return cRightAssignment_1_1; }
+
+ //ShiftOp
+ public RuleCall getRightShiftOpParserRuleCall_1_1_0() { return cRightShiftOpParserRuleCall_1_1_0; }
+ }
+
+ public class ShiftOpElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ShiftOp");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cAdditiveOpParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cGroup_1.eContents().get(0);
+ private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0);
+ private final Action cBinaryExpLeftAction_1_0_0_0 = (Action)cGroup_1_0_0.eContents().get(0);
+ private final Assignment cOperatorAssignment_1_0_0_1 = (Assignment)cGroup_1_0_0.eContents().get(1);
+ private final RuleCall cOperatorSHIFTTerminalRuleCall_1_0_0_1_0 = (RuleCall)cOperatorAssignment_1_0_0_1.eContents().get(0);
+ private final Assignment cRightAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cRightAdditiveOpParserRuleCall_1_1_0 = (RuleCall)cRightAssignment_1_1.eContents().get(0);
+
+ //ShiftOp returns Expression:
+ // AdditiveOp (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*;
+ public ParserRule getRule() { return rule; }
+
+ //AdditiveOp (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*
+ public Group getGroup() { return cGroup; }
+
+ //AdditiveOp
+ public RuleCall getAdditiveOpParserRuleCall_0() { return cAdditiveOpParserRuleCall_0; }
+
+ //(=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //=> ({BinaryExp.left=current} operator=SHIFT)
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //{BinaryExp.left=current} operator=SHIFT
+ public Group getGroup_1_0_0() { return cGroup_1_0_0; }
+
+ //{BinaryExp.left=current}
+ public Action getBinaryExpLeftAction_1_0_0_0() { return cBinaryExpLeftAction_1_0_0_0; }
+
+ //operator=SHIFT
+ public Assignment getOperatorAssignment_1_0_0_1() { return cOperatorAssignment_1_0_0_1; }
+
+ //SHIFT
+ public RuleCall getOperatorSHIFTTerminalRuleCall_1_0_0_1_0() { return cOperatorSHIFTTerminalRuleCall_1_0_0_1_0; }
+
+ //right=AdditiveOp
+ public Assignment getRightAssignment_1_1() { return cRightAssignment_1_1; }
+
+ //AdditiveOp
+ public RuleCall getRightAdditiveOpParserRuleCall_1_1_0() { return cRightAdditiveOpParserRuleCall_1_1_0; }
+ }
+
+ public class AdditiveOpElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "AdditiveOp");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cMathOpParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cGroup_1.eContents().get(0);
+ private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0);
+ private final Action cBinaryExpLeftAction_1_0_0_0 = (Action)cGroup_1_0_0.eContents().get(0);
+ private final Assignment cOperatorAssignment_1_0_0_1 = (Assignment)cGroup_1_0_0.eContents().get(1);
+ private final Alternatives cOperatorAlternatives_1_0_0_1_0 = (Alternatives)cOperatorAssignment_1_0_0_1.eContents().get(0);
+ private final RuleCall cOperatorPLUSTerminalRuleCall_1_0_0_1_0_0 = (RuleCall)cOperatorAlternatives_1_0_0_1_0.eContents().get(0);
+ private final RuleCall cOperatorMINUSTerminalRuleCall_1_0_0_1_0_1 = (RuleCall)cOperatorAlternatives_1_0_0_1_0.eContents().get(1);
+ private final Assignment cRightAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cRightMathOpParserRuleCall_1_1_0 = (RuleCall)cRightAssignment_1_1.eContents().get(0);
+
+ //AdditiveOp returns Expression:
+ // MathOp (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*;
+ public ParserRule getRule() { return rule; }
+
+ //MathOp (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*
+ public Group getGroup() { return cGroup; }
+
+ //MathOp
+ public RuleCall getMathOpParserRuleCall_0() { return cMathOpParserRuleCall_0; }
+
+ //(=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //=> ({BinaryExp.left=current} operator=(PLUS | MINUS))
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //{BinaryExp.left=current} operator=(PLUS | MINUS)
+ public Group getGroup_1_0_0() { return cGroup_1_0_0; }
+
+ //{BinaryExp.left=current}
+ public Action getBinaryExpLeftAction_1_0_0_0() { return cBinaryExpLeftAction_1_0_0_0; }
+
+ //operator=(PLUS | MINUS)
+ public Assignment getOperatorAssignment_1_0_0_1() { return cOperatorAssignment_1_0_0_1; }
+
+ //PLUS | MINUS
+ public Alternatives getOperatorAlternatives_1_0_0_1_0() { return cOperatorAlternatives_1_0_0_1_0; }
+
+ //PLUS
+ public RuleCall getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0() { return cOperatorPLUSTerminalRuleCall_1_0_0_1_0_0; }
+
+ //MINUS
+ public RuleCall getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1() { return cOperatorMINUSTerminalRuleCall_1_0_0_1_0_1; }
+
+ //right=MathOp
+ public Assignment getRightAssignment_1_1() { return cRightAssignment_1_1; }
+
+ //MathOp
+ public RuleCall getRightMathOpParserRuleCall_1_1_0() { return cRightMathOpParserRuleCall_1_1_0; }
+ }
+
+ public class MathOpElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "MathOp");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cUnaryOpParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cGroup_1.eContents().get(0);
+ private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0);
+ private final Action cBinaryExpLeftAction_1_0_0_0 = (Action)cGroup_1_0_0.eContents().get(0);
+ private final Assignment cOperatorAssignment_1_0_0_1 = (Assignment)cGroup_1_0_0.eContents().get(1);
+ private final RuleCall cOperatorMATHTerminalRuleCall_1_0_0_1_0 = (RuleCall)cOperatorAssignment_1_0_0_1.eContents().get(0);
+ private final Assignment cRightAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cRightUnaryOpParserRuleCall_1_1_0 = (RuleCall)cRightAssignment_1_1.eContents().get(0);
+
+ //MathOp returns Expression:
+ // UnaryOp (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*;
+ public ParserRule getRule() { return rule; }
+
+ //UnaryOp (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*
+ public Group getGroup() { return cGroup; }
+
+ //UnaryOp
+ public RuleCall getUnaryOpParserRuleCall_0() { return cUnaryOpParserRuleCall_0; }
+
+ //(=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //=> ({BinaryExp.left=current} operator=MATH)
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //{BinaryExp.left=current} operator=MATH
+ public Group getGroup_1_0_0() { return cGroup_1_0_0; }
+
+ //{BinaryExp.left=current}
+ public Action getBinaryExpLeftAction_1_0_0_0() { return cBinaryExpLeftAction_1_0_0_0; }
+
+ //operator=MATH
+ public Assignment getOperatorAssignment_1_0_0_1() { return cOperatorAssignment_1_0_0_1; }
+
+ //MATH
+ public RuleCall getOperatorMATHTerminalRuleCall_1_0_0_1_0() { return cOperatorMATHTerminalRuleCall_1_0_0_1_0; }
+
+ //right=UnaryOp
+ public Assignment getRightAssignment_1_1() { return cRightAssignment_1_1; }
+
+ //UnaryOp
+ public RuleCall getRightUnaryOpParserRuleCall_1_1_0() { return cRightUnaryOpParserRuleCall_1_1_0; }
+ }
+
+ public class UnaryOpElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "UnaryOp");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+ private final Alternatives cAlternatives_0_0 = (Alternatives)cGroup_0.eContents().get(0);
+ private final RuleCall cUNARYTerminalRuleCall_0_0_0 = (RuleCall)cAlternatives_0_0.eContents().get(0);
+ private final RuleCall cPLUSTerminalRuleCall_0_0_1 = (RuleCall)cAlternatives_0_0.eContents().get(1);
+ private final RuleCall cMINUSTerminalRuleCall_0_0_2 = (RuleCall)cAlternatives_0_0.eContents().get(2);
+ private final RuleCall cExpressionParserRuleCall_0_1 = (RuleCall)cGroup_0.eContents().get(1);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final Alternatives cAlternatives_1_0 = (Alternatives)cGroup_1.eContents().get(0);
+ private final RuleCall cPLUS_PLUSTerminalRuleCall_1_0_0 = (RuleCall)cAlternatives_1_0.eContents().get(0);
+ private final RuleCall cMINUS_MINUSTerminalRuleCall_1_0_1 = (RuleCall)cAlternatives_1_0.eContents().get(1);
+ private final RuleCall cVariableParserRuleCall_1_1 = (RuleCall)cGroup_1.eContents().get(1);
+ private final Group cGroup_2 = (Group)cAlternatives.eContents().get(2);
+ private final RuleCall cApplicationParserRuleCall_2_0 = (RuleCall)cGroup_2.eContents().get(0);
+ private final RuleCall cQUESTIONTerminalRuleCall_2_1 = (RuleCall)cGroup_2.eContents().get(1);
+
+ //UnaryOp returns Expression:
+ // (UNARY | PLUS | MINUS) Expression | (PLUS_PLUS | MINUS_MINUS) Variable | // FIXME: postfix increment
+ // Application QUESTION?;
+ public ParserRule getRule() { return rule; }
+
+ //(UNARY | PLUS | MINUS) Expression | (PLUS_PLUS | MINUS_MINUS) Variable | // FIXME: postfix increment
+ //Application QUESTION?
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //(UNARY | PLUS | MINUS) Expression
+ public Group getGroup_0() { return cGroup_0; }
+
+ //UNARY | PLUS | MINUS
+ public Alternatives getAlternatives_0_0() { return cAlternatives_0_0; }
+
+ //UNARY
+ public RuleCall getUNARYTerminalRuleCall_0_0_0() { return cUNARYTerminalRuleCall_0_0_0; }
+
+ //PLUS
+ public RuleCall getPLUSTerminalRuleCall_0_0_1() { return cPLUSTerminalRuleCall_0_0_1; }
+
+ //MINUS
+ public RuleCall getMINUSTerminalRuleCall_0_0_2() { return cMINUSTerminalRuleCall_0_0_2; }
+
+ //Expression
+ public RuleCall getExpressionParserRuleCall_0_1() { return cExpressionParserRuleCall_0_1; }
+
+ //(PLUS_PLUS | MINUS_MINUS) Variable
+ public Group getGroup_1() { return cGroup_1; }
+
+ //PLUS_PLUS | MINUS_MINUS
+ public Alternatives getAlternatives_1_0() { return cAlternatives_1_0; }
+
+ //PLUS_PLUS
+ public RuleCall getPLUS_PLUSTerminalRuleCall_1_0_0() { return cPLUS_PLUSTerminalRuleCall_1_0_0; }
+
+ //MINUS_MINUS
+ public RuleCall getMINUS_MINUSTerminalRuleCall_1_0_1() { return cMINUS_MINUSTerminalRuleCall_1_0_1; }
+
+ //Variable
+ public RuleCall getVariableParserRuleCall_1_1() { return cVariableParserRuleCall_1_1; }
+
+ //// FIXME: postfix increment
+ //Application QUESTION?
+ public Group getGroup_2() { return cGroup_2; }
+
+ //// FIXME: postfix increment
+ //Application
+ public RuleCall getApplicationParserRuleCall_2_0() { return cApplicationParserRuleCall_2_0; }
+
+ //QUESTION?
+ public RuleCall getQUESTIONTerminalRuleCall_2_1() { return cQUESTIONTerminalRuleCall_2_1; }
+ }
+
+ public class ApplicationElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Application");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+ private final Action cSuperCallAction_0_0 = (Action)cGroup_0.eContents().get(0);
+ private final Group cGroup_0_1 = (Group)cGroup_0.eContents().get(1);
+ private final RuleCall cSUPERTerminalRuleCall_0_1_0 = (RuleCall)cGroup_0_1.eContents().get(0);
+ private final Group cGroup_0_1_1 = (Group)cGroup_0_1.eContents().get(1);
+ private final RuleCall cCALL_STARTTerminalRuleCall_0_1_1_0 = (RuleCall)cGroup_0_1_1.eContents().get(0);
+ private final Assignment cArgsAssignment_0_1_1_1 = (Assignment)cGroup_0_1_1.eContents().get(1);
+ private final RuleCall cArgsArgListParserRuleCall_0_1_1_1_0 = (RuleCall)cArgsAssignment_0_1_1_1.eContents().get(0);
+ private final RuleCall cCALL_ENDTerminalRuleCall_0_1_1_2 = (RuleCall)cGroup_0_1_1.eContents().get(2);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final Assignment cValueAssignment_1_0 = (Assignment)cGroup_1.eContents().get(0);
+ private final RuleCall cValuePrimaryExpressionParserRuleCall_1_0_0 = (RuleCall)cValueAssignment_1_0.eContents().get(0);
+ private final Assignment cFeaturesAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cFeaturesFeatureCallParserRuleCall_1_1_0 = (RuleCall)cFeaturesAssignment_1_1.eContents().get(0);
+
+ //// Nested function calls and property accesses -- I couldn't come up with a better name
+ //Application:
+ // {SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?) | value=PrimaryExpression features+=FeatureCall*;
+ public ParserRule getRule() { return rule; }
+
+ //{SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?) | value=PrimaryExpression features+=FeatureCall*
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //{SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?)
+ public Group getGroup_0() { return cGroup_0; }
+
+ //{SuperCall}
+ public Action getSuperCallAction_0_0() { return cSuperCallAction_0_0; }
+
+ //SUPER (CALL_START args=ArgList CALL_END)?
+ public Group getGroup_0_1() { return cGroup_0_1; }
+
+ //SUPER
+ public RuleCall getSUPERTerminalRuleCall_0_1_0() { return cSUPERTerminalRuleCall_0_1_0; }
+
+ //(CALL_START args=ArgList CALL_END)?
+ public Group getGroup_0_1_1() { return cGroup_0_1_1; }
+
+ //CALL_START
+ public RuleCall getCALL_STARTTerminalRuleCall_0_1_1_0() { return cCALL_STARTTerminalRuleCall_0_1_1_0; }
+
+ //args=ArgList
+ public Assignment getArgsAssignment_0_1_1_1() { return cArgsAssignment_0_1_1_1; }
+
+ //ArgList
+ public RuleCall getArgsArgListParserRuleCall_0_1_1_1_0() { return cArgsArgListParserRuleCall_0_1_1_1_0; }
+
+ //CALL_END
+ public RuleCall getCALL_ENDTerminalRuleCall_0_1_1_2() { return cCALL_ENDTerminalRuleCall_0_1_1_2; }
+
+ //value=PrimaryExpression features+=FeatureCall*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //value=PrimaryExpression
+ public Assignment getValueAssignment_1_0() { return cValueAssignment_1_0; }
+
+ //PrimaryExpression
+ public RuleCall getValuePrimaryExpressionParserRuleCall_1_0_0() { return cValuePrimaryExpressionParserRuleCall_1_0_0; }
+
+ //features+=FeatureCall*
+ public Assignment getFeaturesAssignment_1_1() { return cFeaturesAssignment_1_1; }
+
+ //FeatureCall
+ public RuleCall getFeaturesFeatureCallParserRuleCall_1_1_0() { return cFeaturesFeatureCallParserRuleCall_1_1_0; }
+ }
+
+ public class FeatureCallElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "FeatureCall");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cFunctionCallParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cPropertyAccessParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+
+ //FeatureCall:
+ // FunctionCall | PropertyAccess;
+ public ParserRule getRule() { return rule; }
+
+ //FunctionCall | PropertyAccess
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //FunctionCall
+ public RuleCall getFunctionCallParserRuleCall_0() { return cFunctionCallParserRuleCall_0; }
+
+ //PropertyAccess
+ public RuleCall getPropertyAccessParserRuleCall_1() { return cPropertyAccessParserRuleCall_1; }
+ }
+
+ public class FunctionCallElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "FunctionCall");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cFunctionCallAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cFUNC_EXISTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final RuleCall cCALL_STARTTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2);
+ private final Assignment cArgsAssignment_3 = (Assignment)cGroup.eContents().get(3);
+ private final RuleCall cArgsArgListParserRuleCall_3_0 = (RuleCall)cArgsAssignment_3.eContents().get(0);
+ private final RuleCall cCALL_ENDTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4);
+
+ //FunctionCall:
+ // {FunctionCall} FUNC_EXIST? CALL_START args=ArgList CALL_END;
+ public ParserRule getRule() { return rule; }
+
+ //{FunctionCall} FUNC_EXIST? CALL_START args=ArgList CALL_END
+ public Group getGroup() { return cGroup; }
+
+ //{FunctionCall}
+ public Action getFunctionCallAction_0() { return cFunctionCallAction_0; }
+
+ //FUNC_EXIST?
+ public RuleCall getFUNC_EXISTTerminalRuleCall_1() { return cFUNC_EXISTTerminalRuleCall_1; }
+
+ //CALL_START
+ public RuleCall getCALL_STARTTerminalRuleCall_2() { return cCALL_STARTTerminalRuleCall_2; }
+
+ //args=ArgList
+ public Assignment getArgsAssignment_3() { return cArgsAssignment_3; }
+
+ //ArgList
+ public RuleCall getArgsArgListParserRuleCall_3_0() { return cArgsArgListParserRuleCall_3_0; }
+
+ //CALL_END
+ public RuleCall getCALL_ENDTerminalRuleCall_4() { return cCALL_ENDTerminalRuleCall_4; }
+ }
+
+ public class PropertyAccessElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "PropertyAccess");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cNamedPropertyAccessParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cIndexedPropertyAccessParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+
+ //PropertyAccess:
+ // NamedPropertyAccess | IndexedPropertyAccess;
+ public ParserRule getRule() { return rule; }
+
+ //NamedPropertyAccess | IndexedPropertyAccess
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //NamedPropertyAccess
+ public RuleCall getNamedPropertyAccessParserRuleCall_0() { return cNamedPropertyAccessParserRuleCall_0; }
+
+ //IndexedPropertyAccess
+ public RuleCall getIndexedPropertyAccessParserRuleCall_1() { return cIndexedPropertyAccessParserRuleCall_1; }
+ }
+
+ public class ThisPropertyElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ThisProperty");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cAT_SIGILTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final RuleCall cIdParserRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+
+ //ThisProperty:
+ // AT_SIGIL Id;
+ public ParserRule getRule() { return rule; }
+
+ //AT_SIGIL Id
+ public Group getGroup() { return cGroup; }
+
+ //AT_SIGIL
+ public RuleCall getAT_SIGILTerminalRuleCall_0() { return cAT_SIGILTerminalRuleCall_0; }
+
+ //Id
+ public RuleCall getIdParserRuleCall_1() { return cIdParserRuleCall_1; }
+ }
+
+ public class NamedPropertyAccessElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "NamedPropertyAccess");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+ private final Assignment cAccessorAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0);
+ private final Alternatives cAccessorAlternatives_0_0_0 = (Alternatives)cAccessorAssignment_0_0.eContents().get(0);
+ private final RuleCall cAccessorDOTTerminalRuleCall_0_0_0_0 = (RuleCall)cAccessorAlternatives_0_0_0.eContents().get(0);
+ private final RuleCall cAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1 = (RuleCall)cAccessorAlternatives_0_0_0.eContents().get(1);
+ private final Assignment cNameAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
+ private final RuleCall cNameIdParserRuleCall_0_1_0 = (RuleCall)cNameAssignment_0_1.eContents().get(0);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final Assignment cAccessorAssignment_1_0 = (Assignment)cGroup_1.eContents().get(0);
+ private final RuleCall cAccessorDOUBLE_COLONTerminalRuleCall_1_0_0 = (RuleCall)cAccessorAssignment_1_0.eContents().get(0);
+ private final Assignment cNameAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cNameIdParserRuleCall_1_1_0 = (RuleCall)cNameAssignment_1_1.eContents().get(0);
+
+ //NamedPropertyAccess:
+ // accessor=(DOT | QUESTION_DOT) name=Id | accessor=DOUBLE_COLON name=Id?;
+ public ParserRule getRule() { return rule; }
+
+ //accessor=(DOT | QUESTION_DOT) name=Id | accessor=DOUBLE_COLON name=Id?
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //accessor=(DOT | QUESTION_DOT) name=Id
+ public Group getGroup_0() { return cGroup_0; }
+
+ //accessor=(DOT | QUESTION_DOT)
+ public Assignment getAccessorAssignment_0_0() { return cAccessorAssignment_0_0; }
+
+ //DOT | QUESTION_DOT
+ public Alternatives getAccessorAlternatives_0_0_0() { return cAccessorAlternatives_0_0_0; }
+
+ //DOT
+ public RuleCall getAccessorDOTTerminalRuleCall_0_0_0_0() { return cAccessorDOTTerminalRuleCall_0_0_0_0; }
+
+ //QUESTION_DOT
+ public RuleCall getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1() { return cAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1; }
+
+ //name=Id
+ public Assignment getNameAssignment_0_1() { return cNameAssignment_0_1; }
+
+ //Id
+ public RuleCall getNameIdParserRuleCall_0_1_0() { return cNameIdParserRuleCall_0_1_0; }
+
+ //accessor=DOUBLE_COLON name=Id?
+ public Group getGroup_1() { return cGroup_1; }
+
+ //accessor=DOUBLE_COLON
+ public Assignment getAccessorAssignment_1_0() { return cAccessorAssignment_1_0; }
+
+ //DOUBLE_COLON
+ public RuleCall getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0() { return cAccessorDOUBLE_COLONTerminalRuleCall_1_0_0; }
+
+ //name=Id?
+ public Assignment getNameAssignment_1_1() { return cNameAssignment_1_1; }
+
+ //Id
+ public RuleCall getNameIdParserRuleCall_1_1_0() { return cNameIdParserRuleCall_1_1_0; }
+ }
+
+ public class IndexedPropertyAccessElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "IndexedPropertyAccess");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cINDEX_STARTTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Assignment cIndexAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cIndexIndexParserRuleCall_1_0 = (RuleCall)cIndexAssignment_1.eContents().get(0);
+ private final RuleCall cINDEX_ENDTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2);
+
+ //IndexedPropertyAccess:
+ // INDEX_START index=Index INDEX_END;
+ public ParserRule getRule() { return rule; }
+
+ //INDEX_START index=Index INDEX_END
+ public Group getGroup() { return cGroup; }
+
+ //INDEX_START
+ public RuleCall getINDEX_STARTTerminalRuleCall_0() { return cINDEX_STARTTerminalRuleCall_0; }
+
+ //index=Index
+ public Assignment getIndexAssignment_1() { return cIndexAssignment_1; }
+
+ //Index
+ public RuleCall getIndexIndexParserRuleCall_1_0() { return cIndexIndexParserRuleCall_1_0; }
+
+ //INDEX_END
+ public RuleCall getINDEX_ENDTerminalRuleCall_2() { return cINDEX_ENDTerminalRuleCall_2; }
+ }
+
+ public class IndexElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Index");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+ private final Assignment cDotsAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0);
+ private final Alternatives cDotsAlternatives_0_0_0 = (Alternatives)cDotsAssignment_0_0.eContents().get(0);
+ private final RuleCall cDotsDOT_DOTTerminalRuleCall_0_0_0_0 = (RuleCall)cDotsAlternatives_0_0_0.eContents().get(0);
+ private final RuleCall cDotsELLIPSISTerminalRuleCall_0_0_0_1 = (RuleCall)cDotsAlternatives_0_0_0.eContents().get(1);
+ private final Assignment cEndAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
+ private final RuleCall cEndExpressionParserRuleCall_0_1_0 = (RuleCall)cEndAssignment_0_1.eContents().get(0);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cGroup_1.eContents().get(0);
+ private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0);
+ private final Assignment cStartAssignment_1_0_0_0 = (Assignment)cGroup_1_0_0.eContents().get(0);
+ private final RuleCall cStartExpressionParserRuleCall_1_0_0_0_0 = (RuleCall)cStartAssignment_1_0_0_0.eContents().get(0);
+ private final Assignment cDotsAssignment_1_0_0_1 = (Assignment)cGroup_1_0_0.eContents().get(1);
+ private final Alternatives cDotsAlternatives_1_0_0_1_0 = (Alternatives)cDotsAssignment_1_0_0_1.eContents().get(0);
+ private final RuleCall cDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0 = (RuleCall)cDotsAlternatives_1_0_0_1_0.eContents().get(0);
+ private final RuleCall cDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1 = (RuleCall)cDotsAlternatives_1_0_0_1_0.eContents().get(1);
+ private final Assignment cEndAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cEndExpressionParserRuleCall_1_1_0 = (RuleCall)cEndAssignment_1_1.eContents().get(0);
+ private final Assignment cExpAssignment_2 = (Assignment)cAlternatives.eContents().get(2);
+ private final RuleCall cExpExpressionParserRuleCall_2_0 = (RuleCall)cExpAssignment_2.eContents().get(0);
+
+ //Index:
+ // => dots=(DOT_DOT | ELLIPSIS) end=Expression | => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression? |
+ // exp=Expression;
+ public ParserRule getRule() { return rule; }
+
+ //=> dots=(DOT_DOT | ELLIPSIS) end=Expression | => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression? |
+ //exp=Expression
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //=> dots=(DOT_DOT | ELLIPSIS) end=Expression
+ public Group getGroup_0() { return cGroup_0; }
+
+ //=> dots=(DOT_DOT | ELLIPSIS)
+ public Assignment getDotsAssignment_0_0() { return cDotsAssignment_0_0; }
+
+ //DOT_DOT | ELLIPSIS
+ public Alternatives getDotsAlternatives_0_0_0() { return cDotsAlternatives_0_0_0; }
+
+ //DOT_DOT
+ public RuleCall getDotsDOT_DOTTerminalRuleCall_0_0_0_0() { return cDotsDOT_DOTTerminalRuleCall_0_0_0_0; }
+
+ //ELLIPSIS
+ public RuleCall getDotsELLIPSISTerminalRuleCall_0_0_0_1() { return cDotsELLIPSISTerminalRuleCall_0_0_0_1; }
+
+ //end=Expression
+ public Assignment getEndAssignment_0_1() { return cEndAssignment_0_1; }
+
+ //Expression
+ public RuleCall getEndExpressionParserRuleCall_0_1_0() { return cEndExpressionParserRuleCall_0_1_0; }
+
+ //=> (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression?
+ public Group getGroup_1() { return cGroup_1; }
+
+ //=> (start=Expression dots=(DOT_DOT | ELLIPSIS))
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //start=Expression dots=(DOT_DOT | ELLIPSIS)
+ public Group getGroup_1_0_0() { return cGroup_1_0_0; }
+
+ //start=Expression
+ public Assignment getStartAssignment_1_0_0_0() { return cStartAssignment_1_0_0_0; }
+
+ //Expression
+ public RuleCall getStartExpressionParserRuleCall_1_0_0_0_0() { return cStartExpressionParserRuleCall_1_0_0_0_0; }
+
+ //dots=(DOT_DOT | ELLIPSIS)
+ public Assignment getDotsAssignment_1_0_0_1() { return cDotsAssignment_1_0_0_1; }
+
+ //DOT_DOT | ELLIPSIS
+ public Alternatives getDotsAlternatives_1_0_0_1_0() { return cDotsAlternatives_1_0_0_1_0; }
+
+ //DOT_DOT
+ public RuleCall getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0() { return cDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0; }
+
+ //ELLIPSIS
+ public RuleCall getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1() { return cDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1; }
+
+ //end=Expression?
+ public Assignment getEndAssignment_1_1() { return cEndAssignment_1_1; }
+
+ //Expression
+ public RuleCall getEndExpressionParserRuleCall_1_1_0() { return cEndExpressionParserRuleCall_1_1_0; }
+
+ //exp=Expression
+ public Assignment getExpAssignment_2() { return cExpAssignment_2; }
+
+ //Expression
+ public RuleCall getExpExpressionParserRuleCall_2_0() { return cExpExpressionParserRuleCall_2_0; }
+ }
+
+ public class PrimaryExpressionElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "PrimaryExpression");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cIfExpParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cParentheticalParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+ private final RuleCall cLiteralParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+ private final RuleCall cRangeParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3);
+ private final RuleCall cArrayParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4);
+ private final RuleCall cDictionaryParserRuleCall_5 = (RuleCall)cAlternatives.eContents().get(5);
+ private final RuleCall cLambdaParserRuleCall_6 = (RuleCall)cAlternatives.eContents().get(6);
+ private final RuleCall cThisPropertyParserRuleCall_7 = (RuleCall)cAlternatives.eContents().get(7);
+ private final Group cGroup_8 = (Group)cAlternatives.eContents().get(8);
+ private final Action cThisAloneAction_8_0 = (Action)cGroup_8.eContents().get(0);
+ private final RuleCall cTHISTerminalRuleCall_8_1 = (RuleCall)cGroup_8.eContents().get(1);
+ private final Group cGroup_9 = (Group)cAlternatives.eContents().get(9);
+ private final Action cForAction_9_0 = (Action)cGroup_9.eContents().get(0);
+ private final Group cGroup_9_1 = (Group)cGroup_9.eContents().get(1);
+ private final RuleCall cFORTerminalRuleCall_9_1_0 = (RuleCall)cGroup_9_1.eContents().get(0);
+ private final Assignment cLoopAssignment_9_1_1 = (Assignment)cGroup_9_1.eContents().get(1);
+ private final RuleCall cLoopForBodyParserRuleCall_9_1_1_0 = (RuleCall)cLoopAssignment_9_1_1.eContents().get(0);
+ private final Assignment cBodyAssignment_9_1_2 = (Assignment)cGroup_9_1.eContents().get(2);
+ private final RuleCall cBodyBlockParserRuleCall_9_1_2_0 = (RuleCall)cBodyAssignment_9_1_2.eContents().get(0);
+ private final Group cGroup_10 = (Group)cAlternatives.eContents().get(10);
+ private final Action cWhileAction_10_0 = (Action)cGroup_10.eContents().get(0);
+ private final Group cGroup_10_1 = (Group)cGroup_10.eContents().get(1);
+ private final RuleCall cWHILETerminalRuleCall_10_1_0 = (RuleCall)cGroup_10_1.eContents().get(0);
+ private final Assignment cLoopAssignment_10_1_1 = (Assignment)cGroup_10_1.eContents().get(1);
+ private final RuleCall cLoopExpressionParserRuleCall_10_1_1_0 = (RuleCall)cLoopAssignment_10_1_1.eContents().get(0);
+ private final Group cGroup_10_1_2 = (Group)cGroup_10_1.eContents().get(2);
+ private final RuleCall cWHENTerminalRuleCall_10_1_2_0 = (RuleCall)cGroup_10_1_2.eContents().get(0);
+ private final Assignment cWhenAssignment_10_1_2_1 = (Assignment)cGroup_10_1_2.eContents().get(1);
+ private final RuleCall cWhenExpressionParserRuleCall_10_1_2_1_0 = (RuleCall)cWhenAssignment_10_1_2_1.eContents().get(0);
+ private final Assignment cBodyAssignment_10_1_3 = (Assignment)cGroup_10_1.eContents().get(3);
+ private final RuleCall cBodyBlockParserRuleCall_10_1_3_0 = (RuleCall)cBodyAssignment_10_1_3.eContents().get(0);
+ private final Group cGroup_11 = (Group)cAlternatives.eContents().get(11);
+ private final Action cUntilAction_11_0 = (Action)cGroup_11.eContents().get(0);
+ private final Group cGroup_11_1 = (Group)cGroup_11.eContents().get(1);
+ private final RuleCall cUNTILTerminalRuleCall_11_1_0 = (RuleCall)cGroup_11_1.eContents().get(0);
+ private final Assignment cLoopAssignment_11_1_1 = (Assignment)cGroup_11_1.eContents().get(1);
+ private final RuleCall cLoopExpressionParserRuleCall_11_1_1_0 = (RuleCall)cLoopAssignment_11_1_1.eContents().get(0);
+ private final Group cGroup_11_1_2 = (Group)cGroup_11_1.eContents().get(2);
+ private final RuleCall cWHENTerminalRuleCall_11_1_2_0 = (RuleCall)cGroup_11_1_2.eContents().get(0);
+ private final Assignment cWhenAssignment_11_1_2_1 = (Assignment)cGroup_11_1_2.eContents().get(1);
+ private final RuleCall cWhenExpressionParserRuleCall_11_1_2_1_0 = (RuleCall)cWhenAssignment_11_1_2_1.eContents().get(0);
+ private final Assignment cBodyAssignment_11_1_3 = (Assignment)cGroup_11_1.eContents().get(3);
+ private final RuleCall cBodyBlockParserRuleCall_11_1_3_0 = (RuleCall)cBodyAssignment_11_1_3.eContents().get(0);
+ private final Group cGroup_12 = (Group)cAlternatives.eContents().get(12);
+ private final Action cLoopAction_12_0 = (Action)cGroup_12.eContents().get(0);
+ private final Group cGroup_12_1 = (Group)cGroup_12.eContents().get(1);
+ private final RuleCall cLOOPTerminalRuleCall_12_1_0 = (RuleCall)cGroup_12_1.eContents().get(0);
+ private final Assignment cBodyAssignment_12_1_1 = (Assignment)cGroup_12_1.eContents().get(1);
+ private final RuleCall cBodyBlockParserRuleCall_12_1_1_0 = (RuleCall)cBodyAssignment_12_1_1.eContents().get(0);
+ private final Group cGroup_13 = (Group)cAlternatives.eContents().get(13);
+ private final Action cTryCatchAction_13_0 = (Action)cGroup_13.eContents().get(0);
+ private final Group cGroup_13_1 = (Group)cGroup_13.eContents().get(1);
+ private final RuleCall cTRYTerminalRuleCall_13_1_0 = (RuleCall)cGroup_13_1.eContents().get(0);
+ private final Assignment cBodyAssignment_13_1_1 = (Assignment)cGroup_13_1.eContents().get(1);
+ private final RuleCall cBodyBlockParserRuleCall_13_1_1_0 = (RuleCall)cBodyAssignment_13_1_1.eContents().get(0);
+ private final Alternatives cAlternatives_13_1_2 = (Alternatives)cGroup_13_1.eContents().get(2);
+ private final Group cGroup_13_1_2_0 = (Group)cAlternatives_13_1_2.eContents().get(0);
+ private final RuleCall cCATCHTerminalRuleCall_13_1_2_0_0 = (RuleCall)cGroup_13_1_2_0.eContents().get(0);
+ private final Assignment cExceptionAssignment_13_1_2_0_1 = (Assignment)cGroup_13_1_2_0.eContents().get(1);
+ private final RuleCall cExceptionIdParserRuleCall_13_1_2_0_1_0 = (RuleCall)cExceptionAssignment_13_1_2_0_1.eContents().get(0);
+ private final Assignment cCatchBlockAssignment_13_1_2_0_2 = (Assignment)cGroup_13_1_2_0.eContents().get(2);
+ private final RuleCall cCatchBlockBlockParserRuleCall_13_1_2_0_2_0 = (RuleCall)cCatchBlockAssignment_13_1_2_0_2.eContents().get(0);
+ private final Group cGroup_13_1_2_0_3 = (Group)cGroup_13_1_2_0.eContents().get(3);
+ private final RuleCall cFINALLYTerminalRuleCall_13_1_2_0_3_0 = (RuleCall)cGroup_13_1_2_0_3.eContents().get(0);
+ private final Assignment cFinallyBlockAssignment_13_1_2_0_3_1 = (Assignment)cGroup_13_1_2_0_3.eContents().get(1);
+ private final RuleCall cFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0 = (RuleCall)cFinallyBlockAssignment_13_1_2_0_3_1.eContents().get(0);
+ private final Group cGroup_13_1_2_1 = (Group)cAlternatives_13_1_2.eContents().get(1);
+ private final RuleCall cFINALLYTerminalRuleCall_13_1_2_1_0 = (RuleCall)cGroup_13_1_2_1.eContents().get(0);
+ private final Assignment cFinallyBlockAssignment_13_1_2_1_1 = (Assignment)cGroup_13_1_2_1.eContents().get(1);
+ private final RuleCall cFinallyBlockBlockParserRuleCall_13_1_2_1_1_0 = (RuleCall)cFinallyBlockAssignment_13_1_2_1_1.eContents().get(0);
+ private final Group cGroup_14 = (Group)cAlternatives.eContents().get(14);
+ private final Action cSwitchAction_14_0 = (Action)cGroup_14.eContents().get(0);
+ private final Group cGroup_14_1 = (Group)cGroup_14.eContents().get(1);
+ private final RuleCall cSWITCHTerminalRuleCall_14_1_0 = (RuleCall)cGroup_14_1.eContents().get(0);
+ private final Assignment cExpAssignment_14_1_1 = (Assignment)cGroup_14_1.eContents().get(1);
+ private final RuleCall cExpExpressionParserRuleCall_14_1_1_0 = (RuleCall)cExpAssignment_14_1_1.eContents().get(0);
+ private final RuleCall cINDENTTerminalRuleCall_14_1_2 = (RuleCall)cGroup_14_1.eContents().get(2);
+ private final Assignment cCasesAssignment_14_1_3 = (Assignment)cGroup_14_1.eContents().get(3);
+ private final RuleCall cCasesCaseParserRuleCall_14_1_3_0 = (RuleCall)cCasesAssignment_14_1_3.eContents().get(0);
+ private final Group cGroup_14_1_4 = (Group)cGroup_14_1.eContents().get(4);
+ private final RuleCall cELSETerminalRuleCall_14_1_4_0 = (RuleCall)cGroup_14_1_4.eContents().get(0);
+ private final Assignment cElseBlockAssignment_14_1_4_1 = (Assignment)cGroup_14_1_4.eContents().get(1);
+ private final RuleCall cElseBlockBlockParserRuleCall_14_1_4_1_0 = (RuleCall)cElseBlockAssignment_14_1_4_1.eContents().get(0);
+ private final RuleCall cOUTDENTTerminalRuleCall_14_1_5 = (RuleCall)cGroup_14_1.eContents().get(5);
+ private final RuleCall cIdRefParserRuleCall_15 = (RuleCall)cAlternatives.eContents().get(15);
+
+ //// Try Range before Array
+ //PrimaryExpression:
+ // IfExp | Parenthetical | Literal | Range | Array | Dictionary | Lambda | ThisProperty | {ThisAlone} THIS | {For} (FOR
+ // loop=ForBody body=Block) | {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block) | {Until} (UNTIL
+ // loop=Expression (WHEN when=Expression)? body=Block) | {Loop} (LOOP body=Block) | {TryCatch} (TRY body=Block (CATCH
+ // exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?) | {Switch} (SWITCH
+ // exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT) | IdRef;
+ public ParserRule getRule() { return rule; }
+
+ //IfExp | Parenthetical | Literal | Range | Array | Dictionary | Lambda | ThisProperty | {ThisAlone} THIS | {For} (FOR
+ //loop=ForBody body=Block) | {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block) | {Until} (UNTIL
+ //loop=Expression (WHEN when=Expression)? body=Block) | {Loop} (LOOP body=Block) | {TryCatch} (TRY body=Block (CATCH
+ //exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?) | {Switch} (SWITCH
+ //exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT) | IdRef
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //IfExp
+ public RuleCall getIfExpParserRuleCall_0() { return cIfExpParserRuleCall_0; }
+
+ //Parenthetical
+ public RuleCall getParentheticalParserRuleCall_1() { return cParentheticalParserRuleCall_1; }
+
+ //Literal
+ public RuleCall getLiteralParserRuleCall_2() { return cLiteralParserRuleCall_2; }
+
+ //Range
+ public RuleCall getRangeParserRuleCall_3() { return cRangeParserRuleCall_3; }
+
+ //Array
+ public RuleCall getArrayParserRuleCall_4() { return cArrayParserRuleCall_4; }
+
+ //Dictionary
+ public RuleCall getDictionaryParserRuleCall_5() { return cDictionaryParserRuleCall_5; }
+
+ //Lambda
+ public RuleCall getLambdaParserRuleCall_6() { return cLambdaParserRuleCall_6; }
+
+ //ThisProperty
+ public RuleCall getThisPropertyParserRuleCall_7() { return cThisPropertyParserRuleCall_7; }
+
+ //{ThisAlone} THIS
+ public Group getGroup_8() { return cGroup_8; }
+
+ //{ThisAlone}
+ public Action getThisAloneAction_8_0() { return cThisAloneAction_8_0; }
+
+ //THIS
+ public RuleCall getTHISTerminalRuleCall_8_1() { return cTHISTerminalRuleCall_8_1; }
+
+ //{For} (FOR loop=ForBody body=Block)
+ public Group getGroup_9() { return cGroup_9; }
+
+ //{For}
+ public Action getForAction_9_0() { return cForAction_9_0; }
+
+ //FOR loop=ForBody body=Block
+ public Group getGroup_9_1() { return cGroup_9_1; }
+
+ //FOR
+ public RuleCall getFORTerminalRuleCall_9_1_0() { return cFORTerminalRuleCall_9_1_0; }
+
+ //loop=ForBody
+ public Assignment getLoopAssignment_9_1_1() { return cLoopAssignment_9_1_1; }
+
+ //ForBody
+ public RuleCall getLoopForBodyParserRuleCall_9_1_1_0() { return cLoopForBodyParserRuleCall_9_1_1_0; }
+
+ //body=Block
+ public Assignment getBodyAssignment_9_1_2() { return cBodyAssignment_9_1_2; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_9_1_2_0() { return cBodyBlockParserRuleCall_9_1_2_0; }
+
+ //{While} (WHILE loop=Expression (WHEN when=Expression)? body=Block)
+ public Group getGroup_10() { return cGroup_10; }
+
+ //{While}
+ public Action getWhileAction_10_0() { return cWhileAction_10_0; }
+
+ //WHILE loop=Expression (WHEN when=Expression)? body=Block
+ public Group getGroup_10_1() { return cGroup_10_1; }
+
+ //WHILE
+ public RuleCall getWHILETerminalRuleCall_10_1_0() { return cWHILETerminalRuleCall_10_1_0; }
+
+ //loop=Expression
+ public Assignment getLoopAssignment_10_1_1() { return cLoopAssignment_10_1_1; }
+
+ //Expression
+ public RuleCall getLoopExpressionParserRuleCall_10_1_1_0() { return cLoopExpressionParserRuleCall_10_1_1_0; }
+
+ //(WHEN when=Expression)?
+ public Group getGroup_10_1_2() { return cGroup_10_1_2; }
+
+ //WHEN
+ public RuleCall getWHENTerminalRuleCall_10_1_2_0() { return cWHENTerminalRuleCall_10_1_2_0; }
+
+ //when=Expression
+ public Assignment getWhenAssignment_10_1_2_1() { return cWhenAssignment_10_1_2_1; }
+
+ //Expression
+ public RuleCall getWhenExpressionParserRuleCall_10_1_2_1_0() { return cWhenExpressionParserRuleCall_10_1_2_1_0; }
+
+ //body=Block
+ public Assignment getBodyAssignment_10_1_3() { return cBodyAssignment_10_1_3; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_10_1_3_0() { return cBodyBlockParserRuleCall_10_1_3_0; }
+
+ //{Until} (UNTIL loop=Expression (WHEN when=Expression)? body=Block)
+ public Group getGroup_11() { return cGroup_11; }
+
+ //{Until}
+ public Action getUntilAction_11_0() { return cUntilAction_11_0; }
+
+ //UNTIL loop=Expression (WHEN when=Expression)? body=Block
+ public Group getGroup_11_1() { return cGroup_11_1; }
+
+ //UNTIL
+ public RuleCall getUNTILTerminalRuleCall_11_1_0() { return cUNTILTerminalRuleCall_11_1_0; }
+
+ //loop=Expression
+ public Assignment getLoopAssignment_11_1_1() { return cLoopAssignment_11_1_1; }
+
+ //Expression
+ public RuleCall getLoopExpressionParserRuleCall_11_1_1_0() { return cLoopExpressionParserRuleCall_11_1_1_0; }
+
+ //(WHEN when=Expression)?
+ public Group getGroup_11_1_2() { return cGroup_11_1_2; }
+
+ //WHEN
+ public RuleCall getWHENTerminalRuleCall_11_1_2_0() { return cWHENTerminalRuleCall_11_1_2_0; }
+
+ //when=Expression
+ public Assignment getWhenAssignment_11_1_2_1() { return cWhenAssignment_11_1_2_1; }
+
+ //Expression
+ public RuleCall getWhenExpressionParserRuleCall_11_1_2_1_0() { return cWhenExpressionParserRuleCall_11_1_2_1_0; }
+
+ //body=Block
+ public Assignment getBodyAssignment_11_1_3() { return cBodyAssignment_11_1_3; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_11_1_3_0() { return cBodyBlockParserRuleCall_11_1_3_0; }
+
+ //{Loop} (LOOP body=Block)
+ public Group getGroup_12() { return cGroup_12; }
+
+ //{Loop}
+ public Action getLoopAction_12_0() { return cLoopAction_12_0; }
+
+ //LOOP body=Block
+ public Group getGroup_12_1() { return cGroup_12_1; }
+
+ //LOOP
+ public RuleCall getLOOPTerminalRuleCall_12_1_0() { return cLOOPTerminalRuleCall_12_1_0; }
+
+ //body=Block
+ public Assignment getBodyAssignment_12_1_1() { return cBodyAssignment_12_1_1; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_12_1_1_0() { return cBodyBlockParserRuleCall_12_1_1_0; }
+
+ //{TryCatch} (TRY body=Block (CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY
+ //finallyBlock=Block)?)
+ public Group getGroup_13() { return cGroup_13; }
+
+ //{TryCatch}
+ public Action getTryCatchAction_13_0() { return cTryCatchAction_13_0; }
+
+ //TRY body=Block (CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?
+ public Group getGroup_13_1() { return cGroup_13_1; }
+
+ //TRY
+ public RuleCall getTRYTerminalRuleCall_13_1_0() { return cTRYTerminalRuleCall_13_1_0; }
+
+ //body=Block
+ public Assignment getBodyAssignment_13_1_1() { return cBodyAssignment_13_1_1; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_13_1_1_0() { return cBodyBlockParserRuleCall_13_1_1_0; }
+
+ //(CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?
+ public Alternatives getAlternatives_13_1_2() { return cAlternatives_13_1_2; }
+
+ //CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)?
+ public Group getGroup_13_1_2_0() { return cGroup_13_1_2_0; }
+
+ //CATCH
+ public RuleCall getCATCHTerminalRuleCall_13_1_2_0_0() { return cCATCHTerminalRuleCall_13_1_2_0_0; }
+
+ //exception=Id
+ public Assignment getExceptionAssignment_13_1_2_0_1() { return cExceptionAssignment_13_1_2_0_1; }
+
+ //Id
+ public RuleCall getExceptionIdParserRuleCall_13_1_2_0_1_0() { return cExceptionIdParserRuleCall_13_1_2_0_1_0; }
+
+ //catchBlock=Block
+ public Assignment getCatchBlockAssignment_13_1_2_0_2() { return cCatchBlockAssignment_13_1_2_0_2; }
+
+ //Block
+ public RuleCall getCatchBlockBlockParserRuleCall_13_1_2_0_2_0() { return cCatchBlockBlockParserRuleCall_13_1_2_0_2_0; }
+
+ //(FINALLY finallyBlock=Block)?
+ public Group getGroup_13_1_2_0_3() { return cGroup_13_1_2_0_3; }
+
+ //FINALLY
+ public RuleCall getFINALLYTerminalRuleCall_13_1_2_0_3_0() { return cFINALLYTerminalRuleCall_13_1_2_0_3_0; }
+
+ //finallyBlock=Block
+ public Assignment getFinallyBlockAssignment_13_1_2_0_3_1() { return cFinallyBlockAssignment_13_1_2_0_3_1; }
+
+ //Block
+ public RuleCall getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0() { return cFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0; }
+
+ //FINALLY finallyBlock=Block
+ public Group getGroup_13_1_2_1() { return cGroup_13_1_2_1; }
+
+ //FINALLY
+ public RuleCall getFINALLYTerminalRuleCall_13_1_2_1_0() { return cFINALLYTerminalRuleCall_13_1_2_1_0; }
+
+ //finallyBlock=Block
+ public Assignment getFinallyBlockAssignment_13_1_2_1_1() { return cFinallyBlockAssignment_13_1_2_1_1; }
+
+ //Block
+ public RuleCall getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0() { return cFinallyBlockBlockParserRuleCall_13_1_2_1_1_0; }
+
+ //{Switch} (SWITCH exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT)
+ public Group getGroup_14() { return cGroup_14; }
+
+ //{Switch}
+ public Action getSwitchAction_14_0() { return cSwitchAction_14_0; }
+
+ //SWITCH exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT
+ public Group getGroup_14_1() { return cGroup_14_1; }
+
+ //SWITCH
+ public RuleCall getSWITCHTerminalRuleCall_14_1_0() { return cSWITCHTerminalRuleCall_14_1_0; }
+
+ //exp=Expression?
+ public Assignment getExpAssignment_14_1_1() { return cExpAssignment_14_1_1; }
+
+ //Expression
+ public RuleCall getExpExpressionParserRuleCall_14_1_1_0() { return cExpExpressionParserRuleCall_14_1_1_0; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_14_1_2() { return cINDENTTerminalRuleCall_14_1_2; }
+
+ //cases+=Case*
+ public Assignment getCasesAssignment_14_1_3() { return cCasesAssignment_14_1_3; }
+
+ //Case
+ public RuleCall getCasesCaseParserRuleCall_14_1_3_0() { return cCasesCaseParserRuleCall_14_1_3_0; }
+
+ //(ELSE elseBlock=Block)?
+ public Group getGroup_14_1_4() { return cGroup_14_1_4; }
+
+ //ELSE
+ public RuleCall getELSETerminalRuleCall_14_1_4_0() { return cELSETerminalRuleCall_14_1_4_0; }
+
+ //elseBlock=Block
+ public Assignment getElseBlockAssignment_14_1_4_1() { return cElseBlockAssignment_14_1_4_1; }
+
+ //Block
+ public RuleCall getElseBlockBlockParserRuleCall_14_1_4_1_0() { return cElseBlockBlockParserRuleCall_14_1_4_1_0; }
+
+ //OUTDENT
+ public RuleCall getOUTDENTTerminalRuleCall_14_1_5() { return cOUTDENTTerminalRuleCall_14_1_5; }
+
+ //IdRef
+ public RuleCall getIdRefParserRuleCall_15() { return cIdRefParserRuleCall_15; }
+ }
+
+ public class BlockElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Block");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cBlockAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cINDENTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final RuleCall cBodyParserRuleCall_2 = (RuleCall)cGroup.eContents().get(2);
+ private final RuleCall cOUTDENTTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3);
+
+ //Block:
+ // {Block} INDENT Body? OUTDENT;
+ public ParserRule getRule() { return rule; }
+
+ //{Block} INDENT Body? OUTDENT
+ public Group getGroup() { return cGroup; }
+
+ //{Block}
+ public Action getBlockAction_0() { return cBlockAction_0; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_1() { return cINDENTTerminalRuleCall_1; }
+
+ //Body?
+ public RuleCall getBodyParserRuleCall_2() { return cBodyParserRuleCall_2; }
+
+ //OUTDENT
+ public RuleCall getOUTDENTTerminalRuleCall_3() { return cOUTDENTTerminalRuleCall_3; }
+ }
+
+ public class CaseElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Case");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cLEADING_WHENTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final Assignment cWhensAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cWhensExpressionParserRuleCall_1_0 = (RuleCall)cWhensAssignment_1.eContents().get(0);
+ private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
+ private final RuleCall cCOMMATerminalRuleCall_2_0 = (RuleCall)cGroup_2.eContents().get(0);
+ private final Assignment cWhensAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1);
+ private final RuleCall cWhensExpressionParserRuleCall_2_1_0 = (RuleCall)cWhensAssignment_2_1.eContents().get(0);
+ private final Assignment cThenAssignment_3 = (Assignment)cGroup.eContents().get(3);
+ private final RuleCall cThenBlockParserRuleCall_3_0 = (RuleCall)cThenAssignment_3.eContents().get(0);
+ private final RuleCall cTERMINATORTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4);
+
+ //// a switch case (called When in coffeescript)
+ //Case:
+ // LEADING_WHEN whens+=Expression (COMMA whens+=Expression)* then=Block TERMINATOR?;
+ public ParserRule getRule() { return rule; }
+
+ //LEADING_WHEN whens+=Expression (COMMA whens+=Expression)* then=Block TERMINATOR?
+ public Group getGroup() { return cGroup; }
+
+ //LEADING_WHEN
+ public RuleCall getLEADING_WHENTerminalRuleCall_0() { return cLEADING_WHENTerminalRuleCall_0; }
+
+ //whens+=Expression
+ public Assignment getWhensAssignment_1() { return cWhensAssignment_1; }
+
+ //Expression
+ public RuleCall getWhensExpressionParserRuleCall_1_0() { return cWhensExpressionParserRuleCall_1_0; }
+
+ //(COMMA whens+=Expression)*
+ public Group getGroup_2() { return cGroup_2; }
+
+ //COMMA
+ public RuleCall getCOMMATerminalRuleCall_2_0() { return cCOMMATerminalRuleCall_2_0; }
+
+ //whens+=Expression
+ public Assignment getWhensAssignment_2_1() { return cWhensAssignment_2_1; }
+
+ //Expression
+ public RuleCall getWhensExpressionParserRuleCall_2_1_0() { return cWhensExpressionParserRuleCall_2_1_0; }
+
+ //then=Block
+ public Assignment getThenAssignment_3() { return cThenAssignment_3; }
+
+ //Block
+ public RuleCall getThenBlockParserRuleCall_3_0() { return cThenBlockParserRuleCall_3_0; }
+
+ //TERMINATOR?
+ public RuleCall getTERMINATORTerminalRuleCall_4() { return cTERMINATORTerminalRuleCall_4; }
+ }
+
+ public class IfExpElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "IfExp");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cBlocksAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cBlocksCondBlockParserRuleCall_0_0 = (RuleCall)cBlocksAssignment_0.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final RuleCall cELSETerminalRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0);
+ private final Assignment cBlocksAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cBlocksCondBlockParserRuleCall_1_1_0 = (RuleCall)cBlocksAssignment_1_1.eContents().get(0);
+ private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
+ private final RuleCall cELSETerminalRuleCall_2_0 = (RuleCall)cGroup_2.eContents().get(0);
+ private final Assignment cDefaultBlockAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1);
+ private final RuleCall cDefaultBlockBlockParserRuleCall_2_1_0 = (RuleCall)cDefaultBlockAssignment_2_1.eContents().get(0);
+
+ //IfExp:
+ // blocks+=CondBlock (ELSE blocks+=CondBlock)* (ELSE defaultBlock=Block)?;
+ public ParserRule getRule() { return rule; }
+
+ //blocks+=CondBlock (ELSE blocks+=CondBlock)* (ELSE defaultBlock=Block)?
+ public Group getGroup() { return cGroup; }
+
+ //blocks+=CondBlock
+ public Assignment getBlocksAssignment_0() { return cBlocksAssignment_0; }
+
+ //CondBlock
+ public RuleCall getBlocksCondBlockParserRuleCall_0_0() { return cBlocksCondBlockParserRuleCall_0_0; }
+
+ //(ELSE blocks+=CondBlock)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //ELSE
+ public RuleCall getELSETerminalRuleCall_1_0() { return cELSETerminalRuleCall_1_0; }
+
+ //blocks+=CondBlock
+ public Assignment getBlocksAssignment_1_1() { return cBlocksAssignment_1_1; }
+
+ //CondBlock
+ public RuleCall getBlocksCondBlockParserRuleCall_1_1_0() { return cBlocksCondBlockParserRuleCall_1_1_0; }
+
+ //(ELSE defaultBlock=Block)?
+ public Group getGroup_2() { return cGroup_2; }
+
+ //ELSE
+ public RuleCall getELSETerminalRuleCall_2_0() { return cELSETerminalRuleCall_2_0; }
+
+ //defaultBlock=Block
+ public Assignment getDefaultBlockAssignment_2_1() { return cDefaultBlockAssignment_2_1; }
+
+ //Block
+ public RuleCall getDefaultBlockBlockParserRuleCall_2_1_0() { return cDefaultBlockBlockParserRuleCall_2_1_0; }
+ }
+
+ public class CondBlockElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "CondBlock");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cOperatorAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cOperatorIFTerminalRuleCall_0_0 = (RuleCall)cOperatorAssignment_0.eContents().get(0);
+ private final Assignment cConditionAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cConditionExpressionParserRuleCall_1_0 = (RuleCall)cConditionAssignment_1.eContents().get(0);
+ private final Assignment cActionAssignment_2 = (Assignment)cGroup.eContents().get(2);
+ private final RuleCall cActionBlockParserRuleCall_2_0 = (RuleCall)cActionAssignment_2.eContents().get(0);
+
+ //// IF can be 'if' or 'unless'
+ //CondBlock:
+ // operator=IF condition=Expression action=Block;
+ public ParserRule getRule() { return rule; }
+
+ //operator=IF condition=Expression action=Block
+ public Group getGroup() { return cGroup; }
+
+ //operator=IF
+ public Assignment getOperatorAssignment_0() { return cOperatorAssignment_0; }
+
+ //IF
+ public RuleCall getOperatorIFTerminalRuleCall_0_0() { return cOperatorIFTerminalRuleCall_0_0; }
+
+ //condition=Expression
+ public Assignment getConditionAssignment_1() { return cConditionAssignment_1; }
+
+ //Expression
+ public RuleCall getConditionExpressionParserRuleCall_1_0() { return cConditionExpressionParserRuleCall_1_0; }
+
+ //action=Block
+ public Assignment getActionAssignment_2() { return cActionAssignment_2; }
+
+ //Block
+ public RuleCall getActionBlockParserRuleCall_2_0() { return cActionBlockParserRuleCall_2_0; }
+ }
+
+ public class IdRefElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "IdRef");
+ private final Assignment cValAssignment = (Assignment)rule.eContents().get(1);
+ private final CrossReference cValIdCrossReference_0 = (CrossReference)cValAssignment.eContents().get(0);
+ private final RuleCall cValIdIDENTIFIERTerminalRuleCall_0_1 = (RuleCall)cValIdCrossReference_0.eContents().get(1);
+
+ //IdRef:
+ // val=[Id|IDENTIFIER];
+ public ParserRule getRule() { return rule; }
+
+ //val=[Id|IDENTIFIER]
+ public Assignment getValAssignment() { return cValAssignment; }
+
+ //[Id|IDENTIFIER]
+ public CrossReference getValIdCrossReference_0() { return cValIdCrossReference_0; }
+
+ //IDENTIFIER
+ public RuleCall getValIdIDENTIFIERTerminalRuleCall_0_1() { return cValIdIDENTIFIERTerminalRuleCall_0_1; }
+ }
+
+ public class IdElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Id");
+ private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1);
+ private final RuleCall cNameIDENTIFIERTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0);
+
+ //Id:
+ // name=IDENTIFIER;
+ public ParserRule getRule() { return rule; }
+
+ //name=IDENTIFIER
+ public Assignment getNameAssignment() { return cNameAssignment; }
+
+ //IDENTIFIER
+ public RuleCall getNameIDENTIFIERTerminalRuleCall_0() { return cNameIDENTIFIERTerminalRuleCall_0; }
+ }
+
+ public class PropertyElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Property");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+ private final Group cGroup_0_0 = (Group)cGroup_0.eContents().get(0);
+ private final Group cGroup_0_0_0 = (Group)cGroup_0_0.eContents().get(0);
+ private final RuleCall cIdRefParserRuleCall_0_0_0_0 = (RuleCall)cGroup_0_0_0.eContents().get(0);
+ private final Assignment cAccessorAssignment_0_0_0_1 = (Assignment)cGroup_0_0_0.eContents().get(1);
+ private final Alternatives cAccessorAlternatives_0_0_0_1_0 = (Alternatives)cAccessorAssignment_0_0_0_1.eContents().get(0);
+ private final RuleCall cAccessorDOTTerminalRuleCall_0_0_0_1_0_0 = (RuleCall)cAccessorAlternatives_0_0_0_1_0.eContents().get(0);
+ private final RuleCall cAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1 = (RuleCall)cAccessorAlternatives_0_0_0_1_0.eContents().get(1);
+ private final RuleCall cAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2 = (RuleCall)cAccessorAlternatives_0_0_0_1_0.eContents().get(2);
+ private final Assignment cPropAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
+ private final RuleCall cPropIdParserRuleCall_0_1_0 = (RuleCall)cPropAssignment_0_1.eContents().get(0);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cGroup_1.eContents().get(0);
+ private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0);
+ private final RuleCall cIdRefParserRuleCall_1_0_0_0 = (RuleCall)cGroup_1_0_0.eContents().get(0);
+ private final RuleCall cINDEX_STARTTerminalRuleCall_1_0_0_1 = (RuleCall)cGroup_1_0_0.eContents().get(1);
+ private final Assignment cIndexAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cIndexIndexParserRuleCall_1_1_0 = (RuleCall)cIndexAssignment_1_1.eContents().get(0);
+ private final RuleCall cINDEX_ENDTerminalRuleCall_1_2 = (RuleCall)cGroup_1.eContents().get(2);
+
+ //Property:
+ // => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id // FIXME: property is actually "Expression Accessor"
+ // | => (IdRef INDEX_START) index=Index INDEX_END;
+ public ParserRule getRule() { return rule; }
+
+ //=> (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id // FIXME: property is actually "Expression Accessor"
+ //| => (IdRef INDEX_START) index=Index INDEX_END
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //=> (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id
+ public Group getGroup_0() { return cGroup_0; }
+
+ //=> (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT))
+ public Group getGroup_0_0() { return cGroup_0_0; }
+
+ //IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)
+ public Group getGroup_0_0_0() { return cGroup_0_0_0; }
+
+ //IdRef
+ public RuleCall getIdRefParserRuleCall_0_0_0_0() { return cIdRefParserRuleCall_0_0_0_0; }
+
+ //accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)
+ public Assignment getAccessorAssignment_0_0_0_1() { return cAccessorAssignment_0_0_0_1; }
+
+ //DOT | DOUBLE_COLON | QUESTION_DOT
+ public Alternatives getAccessorAlternatives_0_0_0_1_0() { return cAccessorAlternatives_0_0_0_1_0; }
+
+ //DOT
+ public RuleCall getAccessorDOTTerminalRuleCall_0_0_0_1_0_0() { return cAccessorDOTTerminalRuleCall_0_0_0_1_0_0; }
+
+ //DOUBLE_COLON
+ public RuleCall getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1() { return cAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1; }
+
+ //QUESTION_DOT
+ public RuleCall getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2() { return cAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2; }
+
+ //prop=Id
+ public Assignment getPropAssignment_0_1() { return cPropAssignment_0_1; }
+
+ //Id
+ public RuleCall getPropIdParserRuleCall_0_1_0() { return cPropIdParserRuleCall_0_1_0; }
+
+ //=> (IdRef INDEX_START) index=Index INDEX_END
+ public Group getGroup_1() { return cGroup_1; }
+
+ //=> (IdRef INDEX_START)
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //IdRef INDEX_START
+ public Group getGroup_1_0_0() { return cGroup_1_0_0; }
+
+ //IdRef
+ public RuleCall getIdRefParserRuleCall_1_0_0_0() { return cIdRefParserRuleCall_1_0_0_0; }
+
+ //INDEX_START
+ public RuleCall getINDEX_STARTTerminalRuleCall_1_0_0_1() { return cINDEX_STARTTerminalRuleCall_1_0_0_1; }
+
+ //index=Index
+ public Assignment getIndexAssignment_1_1() { return cIndexAssignment_1_1; }
+
+ //Index
+ public RuleCall getIndexIndexParserRuleCall_1_1_0() { return cIndexIndexParserRuleCall_1_1_0; }
+
+ //INDEX_END
+ public RuleCall getINDEX_ENDTerminalRuleCall_1_2() { return cINDEX_ENDTerminalRuleCall_1_2; }
+ }
+
+ public class VariableElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Variable");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cIdParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final Alternatives cAlternatives_1_0 = (Alternatives)cGroup_1.eContents().get(0);
+ private final RuleCall cAT_SIGILTerminalRuleCall_1_0_0 = (RuleCall)cAlternatives_1_0.eContents().get(0);
+ private final Group cGroup_1_0_1 = (Group)cAlternatives_1_0.eContents().get(1);
+ private final RuleCall cTHISTerminalRuleCall_1_0_1_0 = (RuleCall)cGroup_1_0_1.eContents().get(0);
+ private final RuleCall cDOTTerminalRuleCall_1_0_1_1 = (RuleCall)cGroup_1_0_1.eContents().get(1);
+ private final RuleCall cIdParserRuleCall_1_1 = (RuleCall)cGroup_1.eContents().get(1);
+ private final Group cGroup_1_2 = (Group)cGroup_1.eContents().get(2);
+ private final RuleCall cDOTTerminalRuleCall_1_2_0 = (RuleCall)cGroup_1_2.eContents().get(0);
+ private final Assignment cPropsAssignment_1_2_1 = (Assignment)cGroup_1_2.eContents().get(1);
+ private final RuleCall cPropsIdParserRuleCall_1_2_1_0 = (RuleCall)cPropsAssignment_1_2_1.eContents().get(0);
+ private final RuleCall cPropertyParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+
+ //Variable:
+ // Id | (AT_SIGIL | THIS DOT) Id (DOT props+=Id)* | Property;
+ public ParserRule getRule() { return rule; }
+
+ //Id | (AT_SIGIL | THIS DOT) Id (DOT props+=Id)* | Property
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //Id
+ public RuleCall getIdParserRuleCall_0() { return cIdParserRuleCall_0; }
+
+ //(AT_SIGIL | THIS DOT) Id (DOT props+=Id)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //AT_SIGIL | THIS DOT
+ public Alternatives getAlternatives_1_0() { return cAlternatives_1_0; }
+
+ //AT_SIGIL
+ public RuleCall getAT_SIGILTerminalRuleCall_1_0_0() { return cAT_SIGILTerminalRuleCall_1_0_0; }
+
+ //THIS DOT
+ public Group getGroup_1_0_1() { return cGroup_1_0_1; }
+
+ //THIS
+ public RuleCall getTHISTerminalRuleCall_1_0_1_0() { return cTHISTerminalRuleCall_1_0_1_0; }
+
+ //DOT
+ public RuleCall getDOTTerminalRuleCall_1_0_1_1() { return cDOTTerminalRuleCall_1_0_1_1; }
+
+ //Id
+ public RuleCall getIdParserRuleCall_1_1() { return cIdParserRuleCall_1_1; }
+
+ //(DOT props+=Id)*
+ public Group getGroup_1_2() { return cGroup_1_2; }
+
+ //DOT
+ public RuleCall getDOTTerminalRuleCall_1_2_0() { return cDOTTerminalRuleCall_1_2_0; }
+
+ //props+=Id
+ public Assignment getPropsAssignment_1_2_1() { return cPropsAssignment_1_2_1; }
+
+ //Id
+ public RuleCall getPropsIdParserRuleCall_1_2_1_0() { return cPropsIdParserRuleCall_1_2_1_0; }
+
+ //Property
+ public RuleCall getPropertyParserRuleCall_2() { return cPropertyParserRuleCall_2; }
+ }
+
+ public class AssignableArrayElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "AssignableArray");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cLBRACKETTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final RuleCall cAssignableArgListParserRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final RuleCall cRBRACKETTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2);
+
+ /// ** An array that can be on the left-hand side of an assignment * / AssignableArray:
+ // LBRACKET AssignableArgList RBRACKET;
+ public ParserRule getRule() { return rule; }
+
+ //=> LBRACKET AssignableArgList RBRACKET
+ public Group getGroup() { return cGroup; }
+
+ //=> LBRACKET
+ public RuleCall getLBRACKETTerminalRuleCall_0() { return cLBRACKETTerminalRuleCall_0; }
+
+ //AssignableArgList
+ public RuleCall getAssignableArgListParserRuleCall_1() { return cAssignableArgListParserRuleCall_1; }
+
+ //RBRACKET
+ public RuleCall getRBRACKETTerminalRuleCall_2() { return cRBRACKETTerminalRuleCall_2; }
+ }
+
+ public class AssignableArgListElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "AssignableArgList");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cArgsAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cArgsAssignableArgParserRuleCall_0_0 = (RuleCall)cArgsAssignment_0.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final RuleCall cCOMMATerminalRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0);
+ private final Assignment cArgsAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cArgsAssignableArgParserRuleCall_1_1_0 = (RuleCall)cArgsAssignment_1_1.eContents().get(0);
+
+ //AssignableArgList:
+ // args+=AssignableArg (COMMA args+=AssignableArg)*;
+ public ParserRule getRule() { return rule; }
+
+ //args+=AssignableArg (COMMA args+=AssignableArg)*
+ public Group getGroup() { return cGroup; }
+
+ //args+=AssignableArg
+ public Assignment getArgsAssignment_0() { return cArgsAssignment_0; }
+
+ //AssignableArg
+ public RuleCall getArgsAssignableArgParserRuleCall_0_0() { return cArgsAssignableArgParserRuleCall_0_0; }
+
+ //(COMMA args+=AssignableArg)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //COMMA
+ public RuleCall getCOMMATerminalRuleCall_1_0() { return cCOMMATerminalRuleCall_1_0; }
+
+ //args+=AssignableArg
+ public Assignment getArgsAssignment_1_1() { return cArgsAssignment_1_1; }
+
+ //AssignableArg
+ public RuleCall getArgsAssignableArgParserRuleCall_1_1_0() { return cArgsAssignableArgParserRuleCall_1_1_0; }
+ }
+
+ public class AssignableArgElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "AssignableArg");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cArgAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cArgAssignableParserRuleCall_0_0 = (RuleCall)cArgAssignment_0.eContents().get(0);
+ private final Assignment cSplatAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cSplatELLIPSISTerminalRuleCall_1_0 = (RuleCall)cSplatAssignment_1.eContents().get(0);
+
+ //AssignableArg:
+ // arg=Assignable splat?=ELLIPSIS?;
+ public ParserRule getRule() { return rule; }
+
+ //arg=Assignable splat?=ELLIPSIS?
+ public Group getGroup() { return cGroup; }
+
+ //arg=Assignable
+ public Assignment getArgAssignment_0() { return cArgAssignment_0; }
+
+ //Assignable
+ public RuleCall getArgAssignableParserRuleCall_0_0() { return cArgAssignableParserRuleCall_0_0; }
+
+ //splat?=ELLIPSIS?
+ public Assignment getSplatAssignment_1() { return cSplatAssignment_1; }
+
+ //ELLIPSIS
+ public RuleCall getSplatELLIPSISTerminalRuleCall_1_0() { return cSplatELLIPSISTerminalRuleCall_1_0; }
+ }
+
+ public class AssignableElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Assignable");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cVariableParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cDictionaryParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+ private final RuleCall cAssignableArrayParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+
+ //Assignable:
+ // Variable | Dictionary | AssignableArray;
+ public ParserRule getRule() { return rule; }
+
+ //Variable | Dictionary | AssignableArray
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //Variable
+ public RuleCall getVariableParserRuleCall_0() { return cVariableParserRuleCall_0; }
+
+ //Dictionary
+ public RuleCall getDictionaryParserRuleCall_1() { return cDictionaryParserRuleCall_1; }
+
+ //AssignableArray
+ public RuleCall getAssignableArrayParserRuleCall_2() { return cAssignableArrayParserRuleCall_2; }
+ }
+
+ public class ArgElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Arg");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cExpAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cExpExpressionParserRuleCall_0_0 = (RuleCall)cExpAssignment_0.eContents().get(0);
+ private final Assignment cSplatAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cSplatELLIPSISTerminalRuleCall_1_0 = (RuleCall)cSplatAssignment_1.eContents().get(0);
+
+ /// *
+ // * FIXME: handle more complex assignables
+ // * / Arg:
+ // exp=Expression splat?=ELLIPSIS?;
+ public ParserRule getRule() { return rule; }
+
+ //exp=Expression splat?=ELLIPSIS?
+ public Group getGroup() { return cGroup; }
+
+ //exp=Expression
+ public Assignment getExpAssignment_0() { return cExpAssignment_0; }
+
+ //Expression
+ public RuleCall getExpExpressionParserRuleCall_0_0() { return cExpExpressionParserRuleCall_0_0; }
+
+ //splat?=ELLIPSIS?
+ public Assignment getSplatAssignment_1() { return cSplatAssignment_1; }
+
+ //ELLIPSIS
+ public RuleCall getSplatELLIPSISTerminalRuleCall_1_0() { return cSplatELLIPSISTerminalRuleCall_1_0; }
+ }
+
+ public class ArgLineElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ArgLine");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cHeadAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cHeadArgParserRuleCall_0_0 = (RuleCall)cHeadAssignment_0.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final RuleCall cCOMMATerminalRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0);
+ private final Assignment cTailAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cTailArgParserRuleCall_1_1_0 = (RuleCall)cTailAssignment_1_1.eContents().get(0);
+ private final RuleCall cCOMMATerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2);
+
+ //ArgLine:
+ // head=Arg (COMMA tail+=Arg)* COMMA?;
+ public ParserRule getRule() { return rule; }
+
+ //head=Arg (COMMA tail+=Arg)* COMMA?
+ public Group getGroup() { return cGroup; }
+
+ //head=Arg
+ public Assignment getHeadAssignment_0() { return cHeadAssignment_0; }
+
+ //Arg
+ public RuleCall getHeadArgParserRuleCall_0_0() { return cHeadArgParserRuleCall_0_0; }
+
+ //(COMMA tail+=Arg)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //COMMA
+ public RuleCall getCOMMATerminalRuleCall_1_0() { return cCOMMATerminalRuleCall_1_0; }
+
+ //tail+=Arg
+ public Assignment getTailAssignment_1_1() { return cTailAssignment_1_1; }
+
+ //Arg
+ public RuleCall getTailArgParserRuleCall_1_1_0() { return cTailArgParserRuleCall_1_1_0; }
+
+ //COMMA?
+ public RuleCall getCOMMATerminalRuleCall_2() { return cCOMMATerminalRuleCall_2; }
+ }
+
+ public class ExplicitArgListElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ExplicitArgList");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cLinesAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cLinesArgLineParserRuleCall_0_0 = (RuleCall)cLinesAssignment_0.eContents().get(0);
+ private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0);
+ private final RuleCall cTERMINATORTerminalRuleCall_1_0_0 = (RuleCall)cGroup_1_0.eContents().get(0);
+ private final Assignment cLinesAssignment_1_0_1 = (Assignment)cGroup_1_0.eContents().get(1);
+ private final RuleCall cLinesArgLineParserRuleCall_1_0_1_0 = (RuleCall)cLinesAssignment_1_0_1.eContents().get(0);
+ private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1);
+ private final RuleCall cINDENTTerminalRuleCall_1_1_0 = (RuleCall)cGroup_1_1.eContents().get(0);
+ private final Assignment cLinesAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1);
+ private final RuleCall cLinesArgLineParserRuleCall_1_1_1_0 = (RuleCall)cLinesAssignment_1_1_1.eContents().get(0);
+ private final RuleCall cOUTDENTTerminalRuleCall_1_1_2 = (RuleCall)cGroup_1_1.eContents().get(2);
+
+ //ExplicitArgList:
+ // lines+=ArgLine (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*;
+ public ParserRule getRule() { return rule; }
+
+ //lines+=ArgLine (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*
+ public Group getGroup() { return cGroup; }
+
+ //lines+=ArgLine
+ public Assignment getLinesAssignment_0() { return cLinesAssignment_0; }
+
+ //ArgLine
+ public RuleCall getLinesArgLineParserRuleCall_0_0() { return cLinesArgLineParserRuleCall_0_0; }
+
+ //(TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*
+ public Alternatives getAlternatives_1() { return cAlternatives_1; }
+
+ //TERMINATOR lines+=ArgLine
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //TERMINATOR
+ public RuleCall getTERMINATORTerminalRuleCall_1_0_0() { return cTERMINATORTerminalRuleCall_1_0_0; }
+
+ //lines+=ArgLine
+ public Assignment getLinesAssignment_1_0_1() { return cLinesAssignment_1_0_1; }
+
+ //ArgLine
+ public RuleCall getLinesArgLineParserRuleCall_1_0_1_0() { return cLinesArgLineParserRuleCall_1_0_1_0; }
+
+ //INDENT lines+=ArgLine OUTDENT
+ public Group getGroup_1_1() { return cGroup_1_1; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_1_1_0() { return cINDENTTerminalRuleCall_1_1_0; }
+
+ //lines+=ArgLine
+ public Assignment getLinesAssignment_1_1_1() { return cLinesAssignment_1_1_1; }
+
+ //ArgLine
+ public RuleCall getLinesArgLineParserRuleCall_1_1_1_0() { return cLinesArgLineParserRuleCall_1_1_1_0; }
+
+ //OUTDENT
+ public RuleCall getOUTDENTTerminalRuleCall_1_1_2() { return cOUTDENTTerminalRuleCall_1_1_2; }
+ }
+
+ public class ArgListElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ArgList");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cArgListAction_0 = (Action)cGroup.eContents().get(0);
+ private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1);
+ private final Assignment cDummyAssignment_1_0 = (Assignment)cAlternatives_1.eContents().get(0);
+ private final RuleCall cDummyExplicitArgListParserRuleCall_1_0_0 = (RuleCall)cDummyAssignment_1_0.eContents().get(0);
+ private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1);
+ private final RuleCall cINDENTTerminalRuleCall_1_1_0 = (RuleCall)cGroup_1_1.eContents().get(0);
+ private final Assignment cDummyAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1);
+ private final RuleCall cDummyExplicitArgListParserRuleCall_1_1_1_0 = (RuleCall)cDummyAssignment_1_1_1.eContents().get(0);
+ private final RuleCall cOUTDENTTerminalRuleCall_1_1_2 = (RuleCall)cGroup_1_1.eContents().get(2);
+
+ //ArgList:
+ // {ArgList} (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?;
+ public ParserRule getRule() { return rule; }
+
+ //{ArgList} (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?
+ public Group getGroup() { return cGroup; }
+
+ //{ArgList}
+ public Action getArgListAction_0() { return cArgListAction_0; }
+
+ //(dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?
+ public Alternatives getAlternatives_1() { return cAlternatives_1; }
+
+ //dummy=ExplicitArgList
+ public Assignment getDummyAssignment_1_0() { return cDummyAssignment_1_0; }
+
+ //ExplicitArgList
+ public RuleCall getDummyExplicitArgListParserRuleCall_1_0_0() { return cDummyExplicitArgListParserRuleCall_1_0_0; }
+
+ //INDENT dummy=ExplicitArgList OUTDENT
+ public Group getGroup_1_1() { return cGroup_1_1; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_1_1_0() { return cINDENTTerminalRuleCall_1_1_0; }
+
+ //dummy=ExplicitArgList
+ public Assignment getDummyAssignment_1_1_1() { return cDummyAssignment_1_1_1; }
+
+ //ExplicitArgList
+ public RuleCall getDummyExplicitArgListParserRuleCall_1_1_1_0() { return cDummyExplicitArgListParserRuleCall_1_1_1_0; }
+
+ //OUTDENT
+ public RuleCall getOUTDENTTerminalRuleCall_1_1_2() { return cOUTDENTTerminalRuleCall_1_1_2; }
+ }
+
+ public class ArrayElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Array");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cLBRACKETTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final RuleCall cArgListParserRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final RuleCall cRBRACKETTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2);
+
+ //Array:
+ // LBRACKET ArgList RBRACKET;
+ public ParserRule getRule() { return rule; }
+
+ //=> LBRACKET ArgList RBRACKET
+ public Group getGroup() { return cGroup; }
+
+ //=> LBRACKET
+ public RuleCall getLBRACKETTerminalRuleCall_0() { return cLBRACKETTerminalRuleCall_0; }
+
+ //ArgList
+ public RuleCall getArgListParserRuleCall_1() { return cArgListParserRuleCall_1; }
+
+ //RBRACKET
+ public RuleCall getRBRACKETTerminalRuleCall_2() { return cRBRACKETTerminalRuleCall_2; }
+ }
+
+ public class DictionaryElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Dictionary");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cLCURLYTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final RuleCall cDictItemsParserRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final RuleCall cRCURLYTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2);
+
+ //// Object in coffeescript
+ //Dictionary:
+ // LCURLY DictItems RCURLY;
+ public ParserRule getRule() { return rule; }
+
+ //=> LCURLY DictItems RCURLY
+ public Group getGroup() { return cGroup; }
+
+ //=> LCURLY
+ public RuleCall getLCURLYTerminalRuleCall_0() { return cLCURLYTerminalRuleCall_0; }
+
+ //DictItems
+ public RuleCall getDictItemsParserRuleCall_1() { return cDictItemsParserRuleCall_1; }
+
+ //RCURLY
+ public RuleCall getRCURLYTerminalRuleCall_2() { return cRCURLYTerminalRuleCall_2; }
+ }
+
+ public class DictItemsElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "DictItems");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cDictItemsAction_0 = (Action)cGroup.eContents().get(0);
+ private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1);
+ private final Assignment cDummyAssignment_1_0 = (Assignment)cAlternatives_1.eContents().get(0);
+ private final RuleCall cDummyExplicitDictItemsParserRuleCall_1_0_0 = (RuleCall)cDummyAssignment_1_0.eContents().get(0);
+ private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1);
+ private final RuleCall cINDENTTerminalRuleCall_1_1_0 = (RuleCall)cGroup_1_1.eContents().get(0);
+ private final Assignment cDummyAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1);
+ private final RuleCall cDummyExplicitDictItemsParserRuleCall_1_1_1_0 = (RuleCall)cDummyAssignment_1_1_1.eContents().get(0);
+ private final RuleCall cOUTDENTTerminalRuleCall_1_1_2 = (RuleCall)cGroup_1_1.eContents().get(2);
+
+ //DictItems:
+ // {DictItems} (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?;
+ public ParserRule getRule() { return rule; }
+
+ //{DictItems} (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?
+ public Group getGroup() { return cGroup; }
+
+ //{DictItems}
+ public Action getDictItemsAction_0() { return cDictItemsAction_0; }
+
+ //(dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?
+ public Alternatives getAlternatives_1() { return cAlternatives_1; }
+
+ //dummy=ExplicitDictItems
+ public Assignment getDummyAssignment_1_0() { return cDummyAssignment_1_0; }
+
+ //ExplicitDictItems
+ public RuleCall getDummyExplicitDictItemsParserRuleCall_1_0_0() { return cDummyExplicitDictItemsParserRuleCall_1_0_0; }
+
+ //INDENT dummy=ExplicitDictItems OUTDENT
+ public Group getGroup_1_1() { return cGroup_1_1; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_1_1_0() { return cINDENTTerminalRuleCall_1_1_0; }
+
+ //dummy=ExplicitDictItems
+ public Assignment getDummyAssignment_1_1_1() { return cDummyAssignment_1_1_1; }
+
+ //ExplicitDictItems
+ public RuleCall getDummyExplicitDictItemsParserRuleCall_1_1_1_0() { return cDummyExplicitDictItemsParserRuleCall_1_1_1_0; }
+
+ //OUTDENT
+ public RuleCall getOUTDENTTerminalRuleCall_1_1_2() { return cOUTDENTTerminalRuleCall_1_1_2; }
+ }
+
+ public class ExplicitDictItemsElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ExplicitDictItems");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cLinesAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cLinesDictLineParserRuleCall_0_0 = (RuleCall)cLinesAssignment_0.eContents().get(0);
+ private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1);
+ private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0);
+ private final RuleCall cTERMINATORTerminalRuleCall_1_0_0 = (RuleCall)cGroup_1_0.eContents().get(0);
+ private final Assignment cLinesAssignment_1_0_1 = (Assignment)cGroup_1_0.eContents().get(1);
+ private final RuleCall cLinesDictLineParserRuleCall_1_0_1_0 = (RuleCall)cLinesAssignment_1_0_1.eContents().get(0);
+ private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1);
+ private final RuleCall cINDENTTerminalRuleCall_1_1_0 = (RuleCall)cGroup_1_1.eContents().get(0);
+ private final Assignment cLinesAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1);
+ private final RuleCall cLinesDictLineParserRuleCall_1_1_1_0 = (RuleCall)cLinesAssignment_1_1_1.eContents().get(0);
+ private final RuleCall cOUTDENTTerminalRuleCall_1_1_2 = (RuleCall)cGroup_1_1.eContents().get(2);
+
+ //ExplicitDictItems:
+ // lines+=DictLine (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*;
+ public ParserRule getRule() { return rule; }
+
+ //lines+=DictLine (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*
+ public Group getGroup() { return cGroup; }
+
+ //lines+=DictLine
+ public Assignment getLinesAssignment_0() { return cLinesAssignment_0; }
+
+ //DictLine
+ public RuleCall getLinesDictLineParserRuleCall_0_0() { return cLinesDictLineParserRuleCall_0_0; }
+
+ //(TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*
+ public Alternatives getAlternatives_1() { return cAlternatives_1; }
+
+ //TERMINATOR lines+=DictLine
+ public Group getGroup_1_0() { return cGroup_1_0; }
+
+ //TERMINATOR
+ public RuleCall getTERMINATORTerminalRuleCall_1_0_0() { return cTERMINATORTerminalRuleCall_1_0_0; }
+
+ //lines+=DictLine
+ public Assignment getLinesAssignment_1_0_1() { return cLinesAssignment_1_0_1; }
+
+ //DictLine
+ public RuleCall getLinesDictLineParserRuleCall_1_0_1_0() { return cLinesDictLineParserRuleCall_1_0_1_0; }
+
+ //INDENT lines+=DictLine OUTDENT
+ public Group getGroup_1_1() { return cGroup_1_1; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_1_1_0() { return cINDENTTerminalRuleCall_1_1_0; }
+
+ //lines+=DictLine
+ public Assignment getLinesAssignment_1_1_1() { return cLinesAssignment_1_1_1; }
+
+ //DictLine
+ public RuleCall getLinesDictLineParserRuleCall_1_1_1_0() { return cLinesDictLineParserRuleCall_1_1_1_0; }
+
+ //OUTDENT
+ public RuleCall getOUTDENTTerminalRuleCall_1_1_2() { return cOUTDENTTerminalRuleCall_1_1_2; }
+ }
+
+ public class DictLineElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "DictLine");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cHeadAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cHeadDictItemParserRuleCall_0_0 = (RuleCall)cHeadAssignment_0.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final RuleCall cCOMMATerminalRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0);
+ private final Assignment cTailAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cTailDictItemParserRuleCall_1_1_0 = (RuleCall)cTailAssignment_1_1.eContents().get(0);
+ private final RuleCall cCOMMATerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2);
+
+ //DictLine:
+ // head=DictItem (COMMA tail+=DictItem)* COMMA?;
+ public ParserRule getRule() { return rule; }
+
+ //head=DictItem (COMMA tail+=DictItem)* COMMA?
+ public Group getGroup() { return cGroup; }
+
+ //head=DictItem
+ public Assignment getHeadAssignment_0() { return cHeadAssignment_0; }
+
+ //DictItem
+ public RuleCall getHeadDictItemParserRuleCall_0_0() { return cHeadDictItemParserRuleCall_0_0; }
+
+ //(COMMA tail+=DictItem)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //COMMA
+ public RuleCall getCOMMATerminalRuleCall_1_0() { return cCOMMATerminalRuleCall_1_0; }
+
+ //tail+=DictItem
+ public Assignment getTailAssignment_1_1() { return cTailAssignment_1_1; }
+
+ //DictItem
+ public RuleCall getTailDictItemParserRuleCall_1_1_0() { return cTailDictItemParserRuleCall_1_1_0; }
+
+ //COMMA?
+ public RuleCall getCOMMATerminalRuleCall_2() { return cCOMMATerminalRuleCall_2; }
+ }
+
+ public class DictItemElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "DictItem");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cDictItemAction_0 = (Action)cGroup.eContents().get(0);
+ private final Assignment cKeyAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cKeyDictKeyParserRuleCall_1_0 = (RuleCall)cKeyAssignment_1.eContents().get(0);
+ private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
+ private final RuleCall cCOLONTerminalRuleCall_2_0 = (RuleCall)cGroup_2.eContents().get(0);
+ private final Alternatives cAlternatives_2_1 = (Alternatives)cGroup_2.eContents().get(1);
+ private final Assignment cValueAssignment_2_1_0 = (Assignment)cAlternatives_2_1.eContents().get(0);
+ private final RuleCall cValueExpressionParserRuleCall_2_1_0_0 = (RuleCall)cValueAssignment_2_1_0.eContents().get(0);
+ private final Group cGroup_2_1_1 = (Group)cAlternatives_2_1.eContents().get(1);
+ private final RuleCall cINDENTTerminalRuleCall_2_1_1_0 = (RuleCall)cGroup_2_1_1.eContents().get(0);
+ private final Assignment cValueAssignment_2_1_1_1 = (Assignment)cGroup_2_1_1.eContents().get(1);
+ private final RuleCall cValueExpressionParserRuleCall_2_1_1_1_0 = (RuleCall)cValueAssignment_2_1_1_1.eContents().get(0);
+ private final RuleCall cOUTDENTTerminalRuleCall_2_1_1_2 = (RuleCall)cGroup_2_1_1.eContents().get(2);
+
+ //DictItem:
+ // {DictItem} key=DictKey (COLON (value=Expression | INDENT value=Expression OUTDENT))?;
+ public ParserRule getRule() { return rule; }
+
+ //{DictItem} key=DictKey (COLON (value=Expression | INDENT value=Expression OUTDENT))?
+ public Group getGroup() { return cGroup; }
+
+ //{DictItem}
+ public Action getDictItemAction_0() { return cDictItemAction_0; }
+
+ //key=DictKey
+ public Assignment getKeyAssignment_1() { return cKeyAssignment_1; }
+
+ //DictKey
+ public RuleCall getKeyDictKeyParserRuleCall_1_0() { return cKeyDictKeyParserRuleCall_1_0; }
+
+ //(COLON (value=Expression | INDENT value=Expression OUTDENT))?
+ public Group getGroup_2() { return cGroup_2; }
+
+ //COLON
+ public RuleCall getCOLONTerminalRuleCall_2_0() { return cCOLONTerminalRuleCall_2_0; }
+
+ //value=Expression | INDENT value=Expression OUTDENT
+ public Alternatives getAlternatives_2_1() { return cAlternatives_2_1; }
+
+ //value=Expression
+ public Assignment getValueAssignment_2_1_0() { return cValueAssignment_2_1_0; }
+
+ //Expression
+ public RuleCall getValueExpressionParserRuleCall_2_1_0_0() { return cValueExpressionParserRuleCall_2_1_0_0; }
+
+ //INDENT value=Expression OUTDENT
+ public Group getGroup_2_1_1() { return cGroup_2_1_1; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_2_1_1_0() { return cINDENTTerminalRuleCall_2_1_1_0; }
+
+ //value=Expression
+ public Assignment getValueAssignment_2_1_1_1() { return cValueAssignment_2_1_1_1; }
+
+ //Expression
+ public RuleCall getValueExpressionParserRuleCall_2_1_1_1_0() { return cValueExpressionParserRuleCall_2_1_1_1_0; }
+
+ //OUTDENT
+ public RuleCall getOUTDENTTerminalRuleCall_2_1_1_2() { return cOUTDENTTerminalRuleCall_2_1_1_2; }
+ }
+
+ public class DictKeyElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "DictKey");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cLiteralParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cIdParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+
+ //DictKey:
+ // Literal | Id;
+ public ParserRule getRule() { return rule; }
+
+ //Literal | Id
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //Literal
+ public RuleCall getLiteralParserRuleCall_0() { return cLiteralParserRuleCall_0; }
+
+ //Id
+ public RuleCall getIdParserRuleCall_1() { return cIdParserRuleCall_1; }
+ }
+
+ public class LambdaElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Lambda");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cGroup.eContents().get(0);
+ private final RuleCall cPARAM_STARTTerminalRuleCall_0_0 = (RuleCall)cGroup_0.eContents().get(0);
+ private final Group cGroup_0_1 = (Group)cGroup_0.eContents().get(1);
+ private final Assignment cParamsAssignment_0_1_0 = (Assignment)cGroup_0_1.eContents().get(0);
+ private final RuleCall cParamsParamParserRuleCall_0_1_0_0 = (RuleCall)cParamsAssignment_0_1_0.eContents().get(0);
+ private final Group cGroup_0_1_1 = (Group)cGroup_0_1.eContents().get(1);
+ private final RuleCall cCOMMATerminalRuleCall_0_1_1_0 = (RuleCall)cGroup_0_1_1.eContents().get(0);
+ private final Assignment cParamsAssignment_0_1_1_1 = (Assignment)cGroup_0_1_1.eContents().get(1);
+ private final RuleCall cParamsParamParserRuleCall_0_1_1_1_0 = (RuleCall)cParamsAssignment_0_1_1_1.eContents().get(0);
+ private final RuleCall cPARAM_ENDTerminalRuleCall_0_2 = (RuleCall)cGroup_0.eContents().get(2);
+ private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1);
+ private final RuleCall cFUNC_ARROWTerminalRuleCall_1_0 = (RuleCall)cAlternatives_1.eContents().get(0);
+ private final RuleCall cBOUND_FUNC_ARROWTerminalRuleCall_1_1 = (RuleCall)cAlternatives_1.eContents().get(1);
+ private final Assignment cBodyAssignment_2 = (Assignment)cGroup.eContents().get(2);
+ private final RuleCall cBodyBlockParserRuleCall_2_0 = (RuleCall)cBodyAssignment_2.eContents().get(0);
+
+ //// Code in coffeescript
+ //Lambda:
+ // (PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)? (FUNC_ARROW | BOUND_FUNC_ARROW) body=Block;
+ public ParserRule getRule() { return rule; }
+
+ //(PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)? (FUNC_ARROW | BOUND_FUNC_ARROW) body=Block
+ public Group getGroup() { return cGroup; }
+
+ //(PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)?
+ public Group getGroup_0() { return cGroup_0; }
+
+ //PARAM_START
+ public RuleCall getPARAM_STARTTerminalRuleCall_0_0() { return cPARAM_STARTTerminalRuleCall_0_0; }
+
+ //(params+=Param (COMMA params+=Param)*)?
+ public Group getGroup_0_1() { return cGroup_0_1; }
+
+ //params+=Param
+ public Assignment getParamsAssignment_0_1_0() { return cParamsAssignment_0_1_0; }
+
+ //Param
+ public RuleCall getParamsParamParserRuleCall_0_1_0_0() { return cParamsParamParserRuleCall_0_1_0_0; }
+
+ //(COMMA params+=Param)*
+ public Group getGroup_0_1_1() { return cGroup_0_1_1; }
+
+ //COMMA
+ public RuleCall getCOMMATerminalRuleCall_0_1_1_0() { return cCOMMATerminalRuleCall_0_1_1_0; }
+
+ //params+=Param
+ public Assignment getParamsAssignment_0_1_1_1() { return cParamsAssignment_0_1_1_1; }
+
+ //Param
+ public RuleCall getParamsParamParserRuleCall_0_1_1_1_0() { return cParamsParamParserRuleCall_0_1_1_1_0; }
+
+ //PARAM_END
+ public RuleCall getPARAM_ENDTerminalRuleCall_0_2() { return cPARAM_ENDTerminalRuleCall_0_2; }
+
+ //FUNC_ARROW | BOUND_FUNC_ARROW
+ public Alternatives getAlternatives_1() { return cAlternatives_1; }
+
+ //FUNC_ARROW
+ public RuleCall getFUNC_ARROWTerminalRuleCall_1_0() { return cFUNC_ARROWTerminalRuleCall_1_0; }
+
+ //BOUND_FUNC_ARROW
+ public RuleCall getBOUND_FUNC_ARROWTerminalRuleCall_1_1() { return cBOUND_FUNC_ARROWTerminalRuleCall_1_1; }
+
+ //body=Block
+ public Assignment getBodyAssignment_2() { return cBodyAssignment_2; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_2_0() { return cBodyBlockParserRuleCall_2_0; }
+ }
+
+ public class ParamElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Param");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0);
+ private final RuleCall cIdParserRuleCall_0_0 = (RuleCall)cAlternatives_0.eContents().get(0);
+ private final RuleCall cArrayParserRuleCall_0_1 = (RuleCall)cAlternatives_0.eContents().get(1);
+ private final RuleCall cDictionaryParserRuleCall_0_2 = (RuleCall)cAlternatives_0.eContents().get(2);
+ private final RuleCall cThisPropertyParserRuleCall_0_3 = (RuleCall)cAlternatives_0.eContents().get(3);
+ private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1);
+ private final Assignment cSplatAssignment_1_0 = (Assignment)cAlternatives_1.eContents().get(0);
+ private final RuleCall cSplatELLIPSISTerminalRuleCall_1_0_0 = (RuleCall)cSplatAssignment_1_0.eContents().get(0);
+ private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1);
+ private final RuleCall cEQUALTerminalRuleCall_1_1_0 = (RuleCall)cGroup_1_1.eContents().get(0);
+ private final Assignment cDefaultValueAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1);
+ private final RuleCall cDefaultValueExpressionParserRuleCall_1_1_1_0 = (RuleCall)cDefaultValueAssignment_1_1_1.eContents().get(0);
+
+ //Param:
+ // (Id | Array | Dictionary | ThisProperty) (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?;
+ public ParserRule getRule() { return rule; }
+
+ //(Id | Array | Dictionary | ThisProperty) (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?
+ public Group getGroup() { return cGroup; }
+
+ //Id | Array | Dictionary | ThisProperty
+ public Alternatives getAlternatives_0() { return cAlternatives_0; }
+
+ //Id
+ public RuleCall getIdParserRuleCall_0_0() { return cIdParserRuleCall_0_0; }
+
+ //Array
+ public RuleCall getArrayParserRuleCall_0_1() { return cArrayParserRuleCall_0_1; }
+
+ //Dictionary
+ public RuleCall getDictionaryParserRuleCall_0_2() { return cDictionaryParserRuleCall_0_2; }
+
+ //ThisProperty
+ public RuleCall getThisPropertyParserRuleCall_0_3() { return cThisPropertyParserRuleCall_0_3; }
+
+ //(splat?=ELLIPSIS | EQUAL defaultValue=Expression)?
+ public Alternatives getAlternatives_1() { return cAlternatives_1; }
+
+ //splat?=ELLIPSIS
+ public Assignment getSplatAssignment_1_0() { return cSplatAssignment_1_0; }
+
+ //ELLIPSIS
+ public RuleCall getSplatELLIPSISTerminalRuleCall_1_0_0() { return cSplatELLIPSISTerminalRuleCall_1_0_0; }
+
+ //EQUAL defaultValue=Expression
+ public Group getGroup_1_1() { return cGroup_1_1; }
+
+ //EQUAL
+ public RuleCall getEQUALTerminalRuleCall_1_1_0() { return cEQUALTerminalRuleCall_1_1_0; }
+
+ //defaultValue=Expression
+ public Assignment getDefaultValueAssignment_1_1_1() { return cDefaultValueAssignment_1_1_1; }
+
+ //Expression
+ public RuleCall getDefaultValueExpressionParserRuleCall_1_1_1_0() { return cDefaultValueExpressionParserRuleCall_1_1_1_0; }
+ }
+
+ public class NumberLiteralElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "NumberLiteral");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cNumberLiteralAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cNUMBERTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+
+ //NumberLiteral:
+ // {NumberLiteral} NUMBER;
+ public ParserRule getRule() { return rule; }
+
+ //{NumberLiteral} NUMBER
+ public Group getGroup() { return cGroup; }
+
+ //{NumberLiteral}
+ public Action getNumberLiteralAction_0() { return cNumberLiteralAction_0; }
+
+ //NUMBER
+ public RuleCall getNUMBERTerminalRuleCall_1() { return cNUMBERTerminalRuleCall_1; }
+ }
+
+ public class StringLiteralElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "StringLiteral");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cStringLiteralAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cSTRINGTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+
+ //StringLiteral:
+ // {StringLiteral} STRING;
+ public ParserRule getRule() { return rule; }
+
+ //{StringLiteral} STRING
+ public Group getGroup() { return cGroup; }
+
+ //{StringLiteral}
+ public Action getStringLiteralAction_0() { return cStringLiteralAction_0; }
+
+ //STRING
+ public RuleCall getSTRINGTerminalRuleCall_1() { return cSTRINGTerminalRuleCall_1; }
+ }
+
+ public class BoolLiteralElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "BoolLiteral");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cBoolLiteralAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cBOOLTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+
+ //BoolLiteral:
+ // {BoolLiteral} BOOL;
+ public ParserRule getRule() { return rule; }
+
+ //{BoolLiteral} BOOL
+ public Group getGroup() { return cGroup; }
+
+ //{BoolLiteral}
+ public Action getBoolLiteralAction_0() { return cBoolLiteralAction_0; }
+
+ //BOOL
+ public RuleCall getBOOLTerminalRuleCall_1() { return cBOOLTerminalRuleCall_1; }
+ }
+
+ public class JSLiteralElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "JSLiteral");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cJSLiteralAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cJSTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+
+ //JSLiteral:
+ // {JSLiteral} JS;
+ public ParserRule getRule() { return rule; }
+
+ //{JSLiteral} JS
+ public Group getGroup() { return cGroup; }
+
+ //{JSLiteral}
+ public Action getJSLiteralAction_0() { return cJSLiteralAction_0; }
+
+ //JS
+ public RuleCall getJSTerminalRuleCall_1() { return cJSTerminalRuleCall_1; }
+ }
+
+ public class RegexLiteralElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RegexLiteral");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cRegexLiteralAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cREGEXTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+
+ //RegexLiteral:
+ // {RegexLiteral} REGEX;
+ public ParserRule getRule() { return rule; }
+
+ //{RegexLiteral} REGEX
+ public Group getGroup() { return cGroup; }
+
+ //{RegexLiteral}
+ public Action getRegexLiteralAction_0() { return cRegexLiteralAction_0; }
+
+ //REGEX
+ public RuleCall getREGEXTerminalRuleCall_1() { return cREGEXTerminalRuleCall_1; }
+ }
+
+ public class LiteralElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Literal");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cNumberLiteralParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cStringLiteralParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+ private final RuleCall cBoolLiteralParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+ private final RuleCall cJSLiteralParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3);
+ private final RuleCall cRegexLiteralParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4);
+
+ //Literal:
+ // NumberLiteral | StringLiteral | BoolLiteral | JSLiteral | RegexLiteral;
+ public ParserRule getRule() { return rule; }
+
+ //NumberLiteral | StringLiteral | BoolLiteral | JSLiteral | RegexLiteral
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //NumberLiteral
+ public RuleCall getNumberLiteralParserRuleCall_0() { return cNumberLiteralParserRuleCall_0; }
+
+ //StringLiteral
+ public RuleCall getStringLiteralParserRuleCall_1() { return cStringLiteralParserRuleCall_1; }
+
+ //BoolLiteral
+ public RuleCall getBoolLiteralParserRuleCall_2() { return cBoolLiteralParserRuleCall_2; }
+
+ //JSLiteral
+ public RuleCall getJSLiteralParserRuleCall_3() { return cJSLiteralParserRuleCall_3; }
+
+ //RegexLiteral
+ public RuleCall getRegexLiteralParserRuleCall_4() { return cRegexLiteralParserRuleCall_4; }
+ }
+
+ public class ParentheticalElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Parenthetical");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+ private final Group cGroup_0_0 = (Group)cGroup_0.eContents().get(0);
+ private final Group cGroup_0_0_0 = (Group)cGroup_0_0.eContents().get(0);
+ private final RuleCall cLPARENTerminalRuleCall_0_0_0_0 = (RuleCall)cGroup_0_0_0.eContents().get(0);
+ private final RuleCall cINDENTTerminalRuleCall_0_0_0_1 = (RuleCall)cGroup_0_0_0.eContents().get(1);
+ private final Assignment cContentAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
+ private final RuleCall cContentBodyParserRuleCall_0_1_0 = (RuleCall)cContentAssignment_0_1.eContents().get(0);
+ private final RuleCall cOUTDENTTerminalRuleCall_0_2 = (RuleCall)cGroup_0.eContents().get(2);
+ private final RuleCall cRPARENTerminalRuleCall_0_3 = (RuleCall)cGroup_0.eContents().get(3);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final RuleCall cLPARENTerminalRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0);
+ private final Assignment cContentAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cContentBodyParserRuleCall_1_1_0 = (RuleCall)cContentAssignment_1_1.eContents().get(0);
+ private final RuleCall cRPARENTerminalRuleCall_1_2 = (RuleCall)cGroup_1.eContents().get(2);
+
+ //Parenthetical:
+ // => (LPAREN INDENT) content=Body OUTDENT RPAREN | LPAREN content=Body RPAREN;
+ public ParserRule getRule() { return rule; }
+
+ //=> (LPAREN INDENT) content=Body OUTDENT RPAREN | LPAREN content=Body RPAREN
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //=> (LPAREN INDENT) content=Body OUTDENT RPAREN
+ public Group getGroup_0() { return cGroup_0; }
+
+ //=> (LPAREN INDENT)
+ public Group getGroup_0_0() { return cGroup_0_0; }
+
+ //LPAREN INDENT
+ public Group getGroup_0_0_0() { return cGroup_0_0_0; }
+
+ //LPAREN
+ public RuleCall getLPARENTerminalRuleCall_0_0_0_0() { return cLPARENTerminalRuleCall_0_0_0_0; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_0_0_0_1() { return cINDENTTerminalRuleCall_0_0_0_1; }
+
+ //content=Body
+ public Assignment getContentAssignment_0_1() { return cContentAssignment_0_1; }
+
+ //Body
+ public RuleCall getContentBodyParserRuleCall_0_1_0() { return cContentBodyParserRuleCall_0_1_0; }
+
+ //OUTDENT
+ public RuleCall getOUTDENTTerminalRuleCall_0_2() { return cOUTDENTTerminalRuleCall_0_2; }
+
+ //RPAREN
+ public RuleCall getRPARENTerminalRuleCall_0_3() { return cRPARENTerminalRuleCall_0_3; }
+
+ //=> LPAREN content=Body RPAREN
+ public Group getGroup_1() { return cGroup_1; }
+
+ //=> LPAREN
+ public RuleCall getLPARENTerminalRuleCall_1_0() { return cLPARENTerminalRuleCall_1_0; }
+
+ //content=Body
+ public Assignment getContentAssignment_1_1() { return cContentAssignment_1_1; }
+
+ //Body
+ public RuleCall getContentBodyParserRuleCall_1_1_0() { return cContentBodyParserRuleCall_1_1_0; }
+
+ //RPAREN
+ public RuleCall getRPARENTerminalRuleCall_1_2() { return cRPARENTerminalRuleCall_1_2; }
+ }
+
+
+ private RootElements pRoot;
+ private BodyElements pBody;
+ private LineElements pLine;
+ private StmtElements pStmt;
+ private CommentElements pComment;
+ private RequireStmtElements pRequireStmt;
+ private ReturnStmtElements pReturnStmt;
+ private ThrowStmtElements pThrowStmt;
+ private SuperClassElements pSuperClass;
+ private ClassDeclarationElements pClassDeclaration;
+ private AssignedClassDeclarationElements pAssignedClassDeclaration;
+ private ExpressionElements pExpression;
+ private PostfixElements pPostfix;
+ private ForBodyElements pForBody;
+ private ForValueElements pForValue;
+ private ForSourceElements pForSource;
+ private RangeElements pRange;
+ private AssignmentElements pAssignment;
+ private AssignedElements pAssigned;
+ private LogicOpElements pLogicOp;
+ private CompareOpElements pCompareOp;
+ private RelationOpElements pRelationOp;
+ private ShiftOpElements pShiftOp;
+ private AdditiveOpElements pAdditiveOp;
+ private MathOpElements pMathOp;
+ private UnaryOpElements pUnaryOp;
+ private ApplicationElements pApplication;
+ private FeatureCallElements pFeatureCall;
+ private FunctionCallElements pFunctionCall;
+ private PropertyAccessElements pPropertyAccess;
+ private ThisPropertyElements pThisProperty;
+ private NamedPropertyAccessElements pNamedPropertyAccess;
+ private IndexedPropertyAccessElements pIndexedPropertyAccess;
+ private IndexElements pIndex;
+ private PrimaryExpressionElements pPrimaryExpression;
+ private BlockElements pBlock;
+ private CaseElements pCase;
+ private IfExpElements pIfExp;
+ private CondBlockElements pCondBlock;
+ private IdRefElements pIdRef;
+ private IdElements pId;
+ private PropertyElements pProperty;
+ private VariableElements pVariable;
+ private AssignableArrayElements pAssignableArray;
+ private AssignableArgListElements pAssignableArgList;
+ private AssignableArgElements pAssignableArg;
+ private AssignableElements pAssignable;
+ private ArgElements pArg;
+ private ArgLineElements pArgLine;
+ private ExplicitArgListElements pExplicitArgList;
+ private ArgListElements pArgList;
+ private ArrayElements pArray;
+ private DictionaryElements pDictionary;
+ private DictItemsElements pDictItems;
+ private ExplicitDictItemsElements pExplicitDictItems;
+ private DictLineElements pDictLine;
+ private DictItemElements pDictItem;
+ private DictKeyElements pDictKey;
+ private LambdaElements pLambda;
+ private ParamElements pParam;
+ private NumberLiteralElements pNumberLiteral;
+ private StringLiteralElements pStringLiteral;
+ private BoolLiteralElements pBoolLiteral;
+ private JSLiteralElements pJSLiteral;
+ private RegexLiteralElements pRegexLiteral;
+ private LiteralElements pLiteral;
+ private ParentheticalElements pParenthetical;
+ private TerminalRule tELLIPSIS;
+ private TerminalRule tDOT_DOT;
+ private TerminalRule tDOUBLE_COLON;
+ private TerminalRule tSHIFT;
+ private TerminalRule tBOUND_FUNC_ARROW;
+ private TerminalRule tFUNC_ARROW;
+ private TerminalRule tCOMPARE;
+ private TerminalRule tCOMPOUND_ASSIGN;
+ private TerminalRule tPLUS_PLUS;
+ private TerminalRule tMINUS_MINUS;
+ private TerminalRule tPARAM_END;
+ private TerminalRule tPARAM_START;
+ private TerminalRule tAT_SIGIL;
+ private TerminalRule tBOOL;
+ private TerminalRule tBY;
+ private TerminalRule tCALL_END;
+ private TerminalRule tCALL_START;
+ private TerminalRule tCATCH;
+ private TerminalRule tCLASS;
+ private TerminalRule tCOLON;
+ private TerminalRule tCOLON_SLASH;
+ private TerminalRule tCOMMA;
+ private TerminalRule tDOT;
+ private TerminalRule tELSE;
+ private TerminalRule tEQUAL;
+ private TerminalRule tEXTENDS;
+ private TerminalRule tFINALLY;
+ private TerminalRule tFOR;
+ private TerminalRule tFORIN;
+ private TerminalRule tFOROF;
+ private TerminalRule tFUNC_EXIST;
+ private TerminalRule tHERECOMMENT;
+ private TerminalRule tIF;
+ private TerminalRule tINDENT;
+ private TerminalRule tINDEX_END;
+ private TerminalRule tINDEX_PROTO;
+ private TerminalRule tINDEX_SOAK;
+ private TerminalRule tINDEX_START;
+ private TerminalRule tJS;
+ private TerminalRule tLBRACKET;
+ private TerminalRule tLCURLY;
+ private TerminalRule tLEADING_WHEN;
+ private TerminalRule tLOGIC;
+ private TerminalRule tLOOP;
+ private TerminalRule tLPAREN;
+ private TerminalRule tMATH;
+ private TerminalRule tMINUS;
+ private TerminalRule tNEW;
+ private TerminalRule tNUMBER;
+ private TerminalRule tOUTDENT;
+ private TerminalRule tOWN;
+ private TerminalRule tPLUS;
+ private TerminalRule tPOST_IF;
+ private TerminalRule tQUESTION;
+ private TerminalRule tQUESTION_DOT;
+ private TerminalRule tRBRACKET;
+ private TerminalRule tRCURLY;
+ private TerminalRule tREGEX;
+ private TerminalRule tRELATION;
+ private TerminalRule tRETURN;
+ private TerminalRule tRPAREN;
+ private TerminalRule tSTATEMENT;
+ private TerminalRule tSTRING;
+ private TerminalRule tSUPER;
+ private TerminalRule tSWITCH;
+ private TerminalRule tTERMINATOR;
+ private TerminalRule tTHEN;
+ private TerminalRule tTHIS;
+ private TerminalRule tTHROW;
+ private TerminalRule tTRY;
+ private TerminalRule tUNARY;
+ private TerminalRule tUNTIL;
+ private TerminalRule tWHEN;
+ private TerminalRule tWHILE;
+ private TerminalRule tLOGIC_WORD;
+ private TerminalRule tCOMPARE_WORD;
+ private TerminalRule tUNARY_WORD;
+ private TerminalRule tML_COMMENT;
+ private TerminalRule tSL_COMMENT;
+ private TerminalRule tWS;
+ private TerminalRule tIDENTIFIER;
+
+ private final Grammar grammar;
+
+ @Inject
+ public CoffeeScriptGrammarAccess(GrammarProvider grammarProvider) {
+ this.grammar = internalFindGrammar(grammarProvider);
+ }
+
+ protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
+ Grammar grammar = grammarProvider.getGrammar(this);
+ while (grammar != null) {
+ if ("csep.CoffeeScript".equals(grammar.getName())) {
+ return grammar;
+ }
+ List grammars = grammar.getUsedGrammars();
+ if (!grammars.isEmpty()) {
+ grammar = grammars.iterator().next();
+ } else {
+ return null;
+ }
+ }
+ return grammar;
+ }
+
+
+ public Grammar getGrammar() {
+ return grammar;
+ }
+
+
+
+ //Root:
+ // (Body | Block TERMINATOR)?;
+ public RootElements getRootAccess() {
+ return (pRoot != null) ? pRoot : (pRoot = new RootElements());
+ }
+
+ public ParserRule getRootRule() {
+ return getRootAccess().getRule();
+ }
+
+ //Body:
+ // lines+=Line (TERMINATOR lines+=Line?)*;
+ public BodyElements getBodyAccess() {
+ return (pBody != null) ? pBody : (pBody = new BodyElements());
+ }
+
+ public ParserRule getBodyRule() {
+ return getBodyAccess().getRule();
+ }
+
+ //Line:
+ // Stmt | Expression;
+ public LineElements getLineAccess() {
+ return (pLine != null) ? pLine : (pLine = new LineElements());
+ }
+
+ public ParserRule getLineRule() {
+ return getLineAccess().getRule();
+ }
+
+ //Stmt:
+ // ReturnStmt | ThrowStmt | RequireStmt | Comment | ClassDeclaration | statement=STATEMENT;
+ public StmtElements getStmtAccess() {
+ return (pStmt != null) ? pStmt : (pStmt = new StmtElements());
+ }
+
+ public ParserRule getStmtRule() {
+ return getStmtAccess().getRule();
+ }
+
+ //Comment:
+ // comment=HERECOMMENT;
+ public CommentElements getCommentAccess() {
+ return (pComment != null) ? pComment : (pComment = new CommentElements());
+ }
+
+ public ParserRule getCommentRule() {
+ return getCommentAccess().getRule();
+ }
+
+ /// **
+ // * Treat it a special way, because it takes care of import
+ // * / RequireStmt:
+ // => (importedNamespace=Id EQUAL "require") CALL_START uri=STRING CALL_END;
+ public RequireStmtElements getRequireStmtAccess() {
+ return (pRequireStmt != null) ? pRequireStmt : (pRequireStmt = new RequireStmtElements());
+ }
+
+ public ParserRule getRequireStmtRule() {
+ return getRequireStmtAccess().getRule();
+ }
+
+ //ReturnStmt:
+ // {ReturnStmt} RETURN expression=Expression? (POST_IF condition=Expression)?;
+ public ReturnStmtElements getReturnStmtAccess() {
+ return (pReturnStmt != null) ? pReturnStmt : (pReturnStmt = new ReturnStmtElements());
+ }
+
+ public ParserRule getReturnStmtRule() {
+ return getReturnStmtAccess().getRule();
+ }
+
+ //ThrowStmt:
+ // THROW exp=Expression;
+ public ThrowStmtElements getThrowStmtAccess() {
+ return (pThrowStmt != null) ? pThrowStmt : (pThrowStmt = new ThrowStmtElements());
+ }
+
+ public ParserRule getThrowStmtRule() {
+ return getThrowStmtAccess().getRule();
+ }
+
+ /// **
+ // * Coffeescript is permissive, it can be any expression, but we want to be able to check it as crossref
+ // * / SuperClass:
+ // IdRef | Property;
+ public SuperClassElements getSuperClassAccess() {
+ return (pSuperClass != null) ? pSuperClass : (pSuperClass = new SuperClassElements());
+ }
+
+ public ParserRule getSuperClassRule() {
+ return getSuperClassAccess().getRule();
+ }
+
+ //ClassDeclaration:
+ // {ClassDeclaration} CLASS (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS
+ // extend=SuperClass)? body=Block)?;
+ public ClassDeclarationElements getClassDeclarationAccess() {
+ return (pClassDeclaration != null) ? pClassDeclaration : (pClassDeclaration = new ClassDeclarationElements());
+ }
+
+ public ParserRule getClassDeclarationRule() {
+ return getClassDeclarationAccess().getRule();
+ }
+
+ /// **
+ // * FIXME: it should be the same as ClassDeclaration, but it would result in a non-LL decision,
+ // * so I just removed the problematic options (a class body and a name or a superclass is required).
+ // * / AssignedClassDeclaration:
+ // {ClassDeclaration} CLASS (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)?
+ // body=Block)?;
+ public AssignedClassDeclarationElements getAssignedClassDeclarationAccess() {
+ return (pAssignedClassDeclaration != null) ? pAssignedClassDeclaration : (pAssignedClassDeclaration = new AssignedClassDeclarationElements());
+ }
+
+ public ParserRule getAssignedClassDeclarationRule() {
+ return getAssignedClassDeclarationAccess().getRule();
+ }
+
+ //Expression:
+ // Postfix;
+ public ExpressionElements getExpressionAccess() {
+ return (pExpression != null) ? pExpression : (pExpression = new ExpressionElements());
+ }
+
+ public ParserRule getExpressionRule() {
+ return getExpressionAccess().getRule();
+ }
+
+ //// right-assoc
+ //// Note: the lexer seems to know it should give a POST_IF token here
+ //Postfix returns Expression: //Assignment postfix+=(PostfixIf | ForBody)?;
+ // Assignment (POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE
+ // {While.dummy=current} body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN
+ // when=Expression)?)?;
+ public PostfixElements getPostfixAccess() {
+ return (pPostfix != null) ? pPostfix : (pPostfix = new PostfixElements());
+ }
+
+ public ParserRule getPostfixRule() {
+ return getPostfixAccess().getRule();
+ }
+
+ //ForBody returns Expression: //FIXME: Range |
+ // OWN? indexes+=ForValue (COMMA indexes+=ForValue)* source=ForSource;
+ public ForBodyElements getForBodyAccess() {
+ return (pForBody != null) ? pForBody : (pForBody = new ForBodyElements());
+ }
+
+ public ParserRule getForBodyRule() {
+ return getForBodyAccess().getRule();
+ }
+
+ ////FIXME | Array | Dictionary;
+ //ForValue:
+ // Id;
+ public ForValueElements getForValueAccess() {
+ return (pForValue != null) ? pForValue : (pForValue = new ForValueElements());
+ }
+
+ public ParserRule getForValueRule() {
+ return getForValueAccess().getRule();
+ }
+
+ //ForSource:
+ // {ForSource} (FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY
+ // by=Expression)? | BY by=Expression (WHEN when=Expression)?)?);
+ public ForSourceElements getForSourceAccess() {
+ return (pForSource != null) ? pForSource : (pForSource = new ForSourceElements());
+ }
+
+ public ParserRule getForSourceRule() {
+ return getForSourceAccess().getRule();
+ }
+
+ //Range:
+ // => (LBRACKET start=Expression (DOT_DOT | ELLIPSIS)) end=Expression RBRACKET;
+ public RangeElements getRangeAccess() {
+ return (pRange != null) ? pRange : (pRange = new RangeElements());
+ }
+
+ public ParserRule getRangeRule() {
+ return getRangeAccess().getRule();
+ }
+
+ //Assignment returns Expression:
+ // => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned | LogicOp;
+ public AssignmentElements getAssignmentAccess() {
+ return (pAssignment != null) ? pAssignment : (pAssignment = new AssignmentElements());
+ }
+
+ public ParserRule getAssignmentRule() {
+ return getAssignmentAccess().getRule();
+ }
+
+ //Assigned returns Expression:
+ // Expression | INDENT Expression OUTDENT | AssignedClassDeclaration;
+ public AssignedElements getAssignedAccess() {
+ return (pAssigned != null) ? pAssigned : (pAssigned = new AssignedElements());
+ }
+
+ public ParserRule getAssignedRule() {
+ return getAssignedAccess().getRule();
+ }
+
+ //LogicOp returns Expression:
+ // CompareOp (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*;
+ public LogicOpElements getLogicOpAccess() {
+ return (pLogicOp != null) ? pLogicOp : (pLogicOp = new LogicOpElements());
+ }
+
+ public ParserRule getLogicOpRule() {
+ return getLogicOpAccess().getRule();
+ }
+
+ //CompareOp returns Expression:
+ // RelationOp (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*;
+ public CompareOpElements getCompareOpAccess() {
+ return (pCompareOp != null) ? pCompareOp : (pCompareOp = new CompareOpElements());
+ }
+
+ public ParserRule getCompareOpRule() {
+ return getCompareOpAccess().getRule();
+ }
+
+ //RelationOp returns Expression:
+ // ShiftOp (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*;
+ public RelationOpElements getRelationOpAccess() {
+ return (pRelationOp != null) ? pRelationOp : (pRelationOp = new RelationOpElements());
+ }
+
+ public ParserRule getRelationOpRule() {
+ return getRelationOpAccess().getRule();
+ }
+
+ //ShiftOp returns Expression:
+ // AdditiveOp (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*;
+ public ShiftOpElements getShiftOpAccess() {
+ return (pShiftOp != null) ? pShiftOp : (pShiftOp = new ShiftOpElements());
+ }
+
+ public ParserRule getShiftOpRule() {
+ return getShiftOpAccess().getRule();
+ }
+
+ //AdditiveOp returns Expression:
+ // MathOp (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*;
+ public AdditiveOpElements getAdditiveOpAccess() {
+ return (pAdditiveOp != null) ? pAdditiveOp : (pAdditiveOp = new AdditiveOpElements());
+ }
+
+ public ParserRule getAdditiveOpRule() {
+ return getAdditiveOpAccess().getRule();
+ }
+
+ //MathOp returns Expression:
+ // UnaryOp (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*;
+ public MathOpElements getMathOpAccess() {
+ return (pMathOp != null) ? pMathOp : (pMathOp = new MathOpElements());
+ }
+
+ public ParserRule getMathOpRule() {
+ return getMathOpAccess().getRule();
+ }
+
+ //UnaryOp returns Expression:
+ // (UNARY | PLUS | MINUS) Expression | (PLUS_PLUS | MINUS_MINUS) Variable | // FIXME: postfix increment
+ // Application QUESTION?;
+ public UnaryOpElements getUnaryOpAccess() {
+ return (pUnaryOp != null) ? pUnaryOp : (pUnaryOp = new UnaryOpElements());
+ }
+
+ public ParserRule getUnaryOpRule() {
+ return getUnaryOpAccess().getRule();
+ }
+
+ //// Nested function calls and property accesses -- I couldn't come up with a better name
+ //Application:
+ // {SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?) | value=PrimaryExpression features+=FeatureCall*;
+ public ApplicationElements getApplicationAccess() {
+ return (pApplication != null) ? pApplication : (pApplication = new ApplicationElements());
+ }
+
+ public ParserRule getApplicationRule() {
+ return getApplicationAccess().getRule();
+ }
+
+ //FeatureCall:
+ // FunctionCall | PropertyAccess;
+ public FeatureCallElements getFeatureCallAccess() {
+ return (pFeatureCall != null) ? pFeatureCall : (pFeatureCall = new FeatureCallElements());
+ }
+
+ public ParserRule getFeatureCallRule() {
+ return getFeatureCallAccess().getRule();
+ }
+
+ //FunctionCall:
+ // {FunctionCall} FUNC_EXIST? CALL_START args=ArgList CALL_END;
+ public FunctionCallElements getFunctionCallAccess() {
+ return (pFunctionCall != null) ? pFunctionCall : (pFunctionCall = new FunctionCallElements());
+ }
+
+ public ParserRule getFunctionCallRule() {
+ return getFunctionCallAccess().getRule();
+ }
+
+ //PropertyAccess:
+ // NamedPropertyAccess | IndexedPropertyAccess;
+ public PropertyAccessElements getPropertyAccessAccess() {
+ return (pPropertyAccess != null) ? pPropertyAccess : (pPropertyAccess = new PropertyAccessElements());
+ }
+
+ public ParserRule getPropertyAccessRule() {
+ return getPropertyAccessAccess().getRule();
+ }
+
+ //ThisProperty:
+ // AT_SIGIL Id;
+ public ThisPropertyElements getThisPropertyAccess() {
+ return (pThisProperty != null) ? pThisProperty : (pThisProperty = new ThisPropertyElements());
+ }
+
+ public ParserRule getThisPropertyRule() {
+ return getThisPropertyAccess().getRule();
+ }
+
+ //NamedPropertyAccess:
+ // accessor=(DOT | QUESTION_DOT) name=Id | accessor=DOUBLE_COLON name=Id?;
+ public NamedPropertyAccessElements getNamedPropertyAccessAccess() {
+ return (pNamedPropertyAccess != null) ? pNamedPropertyAccess : (pNamedPropertyAccess = new NamedPropertyAccessElements());
+ }
+
+ public ParserRule getNamedPropertyAccessRule() {
+ return getNamedPropertyAccessAccess().getRule();
+ }
+
+ //IndexedPropertyAccess:
+ // INDEX_START index=Index INDEX_END;
+ public IndexedPropertyAccessElements getIndexedPropertyAccessAccess() {
+ return (pIndexedPropertyAccess != null) ? pIndexedPropertyAccess : (pIndexedPropertyAccess = new IndexedPropertyAccessElements());
+ }
+
+ public ParserRule getIndexedPropertyAccessRule() {
+ return getIndexedPropertyAccessAccess().getRule();
+ }
+
+ //Index:
+ // => dots=(DOT_DOT | ELLIPSIS) end=Expression | => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression? |
+ // exp=Expression;
+ public IndexElements getIndexAccess() {
+ return (pIndex != null) ? pIndex : (pIndex = new IndexElements());
+ }
+
+ public ParserRule getIndexRule() {
+ return getIndexAccess().getRule();
+ }
+
+ //// Try Range before Array
+ //PrimaryExpression:
+ // IfExp | Parenthetical | Literal | Range | Array | Dictionary | Lambda | ThisProperty | {ThisAlone} THIS | {For} (FOR
+ // loop=ForBody body=Block) | {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block) | {Until} (UNTIL
+ // loop=Expression (WHEN when=Expression)? body=Block) | {Loop} (LOOP body=Block) | {TryCatch} (TRY body=Block (CATCH
+ // exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?) | {Switch} (SWITCH
+ // exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT) | IdRef;
+ public PrimaryExpressionElements getPrimaryExpressionAccess() {
+ return (pPrimaryExpression != null) ? pPrimaryExpression : (pPrimaryExpression = new PrimaryExpressionElements());
+ }
+
+ public ParserRule getPrimaryExpressionRule() {
+ return getPrimaryExpressionAccess().getRule();
+ }
+
+ //Block:
+ // {Block} INDENT Body? OUTDENT;
+ public BlockElements getBlockAccess() {
+ return (pBlock != null) ? pBlock : (pBlock = new BlockElements());
+ }
+
+ public ParserRule getBlockRule() {
+ return getBlockAccess().getRule();
+ }
+
+ //// a switch case (called When in coffeescript)
+ //Case:
+ // LEADING_WHEN whens+=Expression (COMMA whens+=Expression)* then=Block TERMINATOR?;
+ public CaseElements getCaseAccess() {
+ return (pCase != null) ? pCase : (pCase = new CaseElements());
+ }
+
+ public ParserRule getCaseRule() {
+ return getCaseAccess().getRule();
+ }
+
+ //IfExp:
+ // blocks+=CondBlock (ELSE blocks+=CondBlock)* (ELSE defaultBlock=Block)?;
+ public IfExpElements getIfExpAccess() {
+ return (pIfExp != null) ? pIfExp : (pIfExp = new IfExpElements());
+ }
+
+ public ParserRule getIfExpRule() {
+ return getIfExpAccess().getRule();
+ }
+
+ //// IF can be 'if' or 'unless'
+ //CondBlock:
+ // operator=IF condition=Expression action=Block;
+ public CondBlockElements getCondBlockAccess() {
+ return (pCondBlock != null) ? pCondBlock : (pCondBlock = new CondBlockElements());
+ }
+
+ public ParserRule getCondBlockRule() {
+ return getCondBlockAccess().getRule();
+ }
+
+ //IdRef:
+ // val=[Id|IDENTIFIER];
+ public IdRefElements getIdRefAccess() {
+ return (pIdRef != null) ? pIdRef : (pIdRef = new IdRefElements());
+ }
+
+ public ParserRule getIdRefRule() {
+ return getIdRefAccess().getRule();
+ }
+
+ //Id:
+ // name=IDENTIFIER;
+ public IdElements getIdAccess() {
+ return (pId != null) ? pId : (pId = new IdElements());
+ }
+
+ public ParserRule getIdRule() {
+ return getIdAccess().getRule();
+ }
+
+ //Property:
+ // => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id // FIXME: property is actually "Expression Accessor"
+ // | => (IdRef INDEX_START) index=Index INDEX_END;
+ public PropertyElements getPropertyAccess() {
+ return (pProperty != null) ? pProperty : (pProperty = new PropertyElements());
+ }
+
+ public ParserRule getPropertyRule() {
+ return getPropertyAccess().getRule();
+ }
+
+ //Variable:
+ // Id | (AT_SIGIL | THIS DOT) Id (DOT props+=Id)* | Property;
+ public VariableElements getVariableAccess() {
+ return (pVariable != null) ? pVariable : (pVariable = new VariableElements());
+ }
+
+ public ParserRule getVariableRule() {
+ return getVariableAccess().getRule();
+ }
+
+ /// ** An array that can be on the left-hand side of an assignment * / AssignableArray:
+ // LBRACKET AssignableArgList RBRACKET;
+ public AssignableArrayElements getAssignableArrayAccess() {
+ return (pAssignableArray != null) ? pAssignableArray : (pAssignableArray = new AssignableArrayElements());
+ }
+
+ public ParserRule getAssignableArrayRule() {
+ return getAssignableArrayAccess().getRule();
+ }
+
+ //AssignableArgList:
+ // args+=AssignableArg (COMMA args+=AssignableArg)*;
+ public AssignableArgListElements getAssignableArgListAccess() {
+ return (pAssignableArgList != null) ? pAssignableArgList : (pAssignableArgList = new AssignableArgListElements());
+ }
+
+ public ParserRule getAssignableArgListRule() {
+ return getAssignableArgListAccess().getRule();
+ }
+
+ //AssignableArg:
+ // arg=Assignable splat?=ELLIPSIS?;
+ public AssignableArgElements getAssignableArgAccess() {
+ return (pAssignableArg != null) ? pAssignableArg : (pAssignableArg = new AssignableArgElements());
+ }
+
+ public ParserRule getAssignableArgRule() {
+ return getAssignableArgAccess().getRule();
+ }
+
+ //Assignable:
+ // Variable | Dictionary | AssignableArray;
+ public AssignableElements getAssignableAccess() {
+ return (pAssignable != null) ? pAssignable : (pAssignable = new AssignableElements());
+ }
+
+ public ParserRule getAssignableRule() {
+ return getAssignableAccess().getRule();
+ }
+
+ /// *
+ // * FIXME: handle more complex assignables
+ // * / Arg:
+ // exp=Expression splat?=ELLIPSIS?;
+ public ArgElements getArgAccess() {
+ return (pArg != null) ? pArg : (pArg = new ArgElements());
+ }
+
+ public ParserRule getArgRule() {
+ return getArgAccess().getRule();
+ }
+
+ //ArgLine:
+ // head=Arg (COMMA tail+=Arg)* COMMA?;
+ public ArgLineElements getArgLineAccess() {
+ return (pArgLine != null) ? pArgLine : (pArgLine = new ArgLineElements());
+ }
+
+ public ParserRule getArgLineRule() {
+ return getArgLineAccess().getRule();
+ }
+
+ //ExplicitArgList:
+ // lines+=ArgLine (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*;
+ public ExplicitArgListElements getExplicitArgListAccess() {
+ return (pExplicitArgList != null) ? pExplicitArgList : (pExplicitArgList = new ExplicitArgListElements());
+ }
+
+ public ParserRule getExplicitArgListRule() {
+ return getExplicitArgListAccess().getRule();
+ }
+
+ //ArgList:
+ // {ArgList} (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?;
+ public ArgListElements getArgListAccess() {
+ return (pArgList != null) ? pArgList : (pArgList = new ArgListElements());
+ }
+
+ public ParserRule getArgListRule() {
+ return getArgListAccess().getRule();
+ }
+
+ //Array:
+ // LBRACKET ArgList RBRACKET;
+ public ArrayElements getArrayAccess() {
+ return (pArray != null) ? pArray : (pArray = new ArrayElements());
+ }
+
+ public ParserRule getArrayRule() {
+ return getArrayAccess().getRule();
+ }
+
+ //// Object in coffeescript
+ //Dictionary:
+ // LCURLY DictItems RCURLY;
+ public DictionaryElements getDictionaryAccess() {
+ return (pDictionary != null) ? pDictionary : (pDictionary = new DictionaryElements());
+ }
+
+ public ParserRule getDictionaryRule() {
+ return getDictionaryAccess().getRule();
+ }
+
+ //DictItems:
+ // {DictItems} (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?;
+ public DictItemsElements getDictItemsAccess() {
+ return (pDictItems != null) ? pDictItems : (pDictItems = new DictItemsElements());
+ }
+
+ public ParserRule getDictItemsRule() {
+ return getDictItemsAccess().getRule();
+ }
+
+ //ExplicitDictItems:
+ // lines+=DictLine (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*;
+ public ExplicitDictItemsElements getExplicitDictItemsAccess() {
+ return (pExplicitDictItems != null) ? pExplicitDictItems : (pExplicitDictItems = new ExplicitDictItemsElements());
+ }
+
+ public ParserRule getExplicitDictItemsRule() {
+ return getExplicitDictItemsAccess().getRule();
+ }
+
+ //DictLine:
+ // head=DictItem (COMMA tail+=DictItem)* COMMA?;
+ public DictLineElements getDictLineAccess() {
+ return (pDictLine != null) ? pDictLine : (pDictLine = new DictLineElements());
+ }
+
+ public ParserRule getDictLineRule() {
+ return getDictLineAccess().getRule();
+ }
+
+ //DictItem:
+ // {DictItem} key=DictKey (COLON (value=Expression | INDENT value=Expression OUTDENT))?;
+ public DictItemElements getDictItemAccess() {
+ return (pDictItem != null) ? pDictItem : (pDictItem = new DictItemElements());
+ }
+
+ public ParserRule getDictItemRule() {
+ return getDictItemAccess().getRule();
+ }
+
+ //DictKey:
+ // Literal | Id;
+ public DictKeyElements getDictKeyAccess() {
+ return (pDictKey != null) ? pDictKey : (pDictKey = new DictKeyElements());
+ }
+
+ public ParserRule getDictKeyRule() {
+ return getDictKeyAccess().getRule();
+ }
+
+ //// Code in coffeescript
+ //Lambda:
+ // (PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)? (FUNC_ARROW | BOUND_FUNC_ARROW) body=Block;
+ public LambdaElements getLambdaAccess() {
+ return (pLambda != null) ? pLambda : (pLambda = new LambdaElements());
+ }
+
+ public ParserRule getLambdaRule() {
+ return getLambdaAccess().getRule();
+ }
+
+ //Param:
+ // (Id | Array | Dictionary | ThisProperty) (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?;
+ public ParamElements getParamAccess() {
+ return (pParam != null) ? pParam : (pParam = new ParamElements());
+ }
+
+ public ParserRule getParamRule() {
+ return getParamAccess().getRule();
+ }
+
+ //NumberLiteral:
+ // {NumberLiteral} NUMBER;
+ public NumberLiteralElements getNumberLiteralAccess() {
+ return (pNumberLiteral != null) ? pNumberLiteral : (pNumberLiteral = new NumberLiteralElements());
+ }
+
+ public ParserRule getNumberLiteralRule() {
+ return getNumberLiteralAccess().getRule();
+ }
+
+ //StringLiteral:
+ // {StringLiteral} STRING;
+ public StringLiteralElements getStringLiteralAccess() {
+ return (pStringLiteral != null) ? pStringLiteral : (pStringLiteral = new StringLiteralElements());
+ }
+
+ public ParserRule getStringLiteralRule() {
+ return getStringLiteralAccess().getRule();
+ }
+
+ //BoolLiteral:
+ // {BoolLiteral} BOOL;
+ public BoolLiteralElements getBoolLiteralAccess() {
+ return (pBoolLiteral != null) ? pBoolLiteral : (pBoolLiteral = new BoolLiteralElements());
+ }
+
+ public ParserRule getBoolLiteralRule() {
+ return getBoolLiteralAccess().getRule();
+ }
+
+ //JSLiteral:
+ // {JSLiteral} JS;
+ public JSLiteralElements getJSLiteralAccess() {
+ return (pJSLiteral != null) ? pJSLiteral : (pJSLiteral = new JSLiteralElements());
+ }
+
+ public ParserRule getJSLiteralRule() {
+ return getJSLiteralAccess().getRule();
+ }
+
+ //RegexLiteral:
+ // {RegexLiteral} REGEX;
+ public RegexLiteralElements getRegexLiteralAccess() {
+ return (pRegexLiteral != null) ? pRegexLiteral : (pRegexLiteral = new RegexLiteralElements());
+ }
+
+ public ParserRule getRegexLiteralRule() {
+ return getRegexLiteralAccess().getRule();
+ }
+
+ //Literal:
+ // NumberLiteral | StringLiteral | BoolLiteral | JSLiteral | RegexLiteral;
+ public LiteralElements getLiteralAccess() {
+ return (pLiteral != null) ? pLiteral : (pLiteral = new LiteralElements());
+ }
+
+ public ParserRule getLiteralRule() {
+ return getLiteralAccess().getRule();
+ }
+
+ //Parenthetical:
+ // => (LPAREN INDENT) content=Body OUTDENT RPAREN | LPAREN content=Body RPAREN;
+ public ParentheticalElements getParentheticalAccess() {
+ return (pParenthetical != null) ? pParenthetical : (pParenthetical = new ParentheticalElements());
+ }
+
+ public ParserRule getParentheticalRule() {
+ return getParentheticalAccess().getRule();
+ }
+
+ //// terminals {{{
+ /// * Note: these are only to enable debugging with Antlworks,
+ // * The actual tokens are provided by the lexer.
+ // * The debugger is smart in some cases, and emits different tokens
+ // * for the same character depending on the context.
+ // * For example
+ // * "(1)" -> LPAREN NUMBER RPAREN
+ // * "func()" -> IDENTIFIER CALL_START CALL_END
+ // * But the debugger expects different strings for the tokens,
+ // * so special ones get an additional asterisk:
+ // * LPAREN: '('
+ // * CALL_START: '(*'
+ // *
+ // * To imitate indentation while debugging, use INDENT and OUTDENT, like this
+ // * if maybe {*
+ // * action()
+ // * *}
+ // * else {*
+ // * wait()
+ // * *}
+ // * / // compound terminals at the beginning to they don't get shadowed
+ //terminal ELLIPSIS:
+ // "...";
+ public TerminalRule getELLIPSISRule() {
+ return (tELLIPSIS != null) ? tELLIPSIS : (tELLIPSIS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "ELLIPSIS"));
+ }
+
+ //terminal DOT_DOT:
+ // "..";
+ public TerminalRule getDOT_DOTRule() {
+ return (tDOT_DOT != null) ? tDOT_DOT : (tDOT_DOT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "DOT_DOT"));
+ }
+
+ //terminal DOUBLE_COLON:
+ // "::";
+ public TerminalRule getDOUBLE_COLONRule() {
+ return (tDOUBLE_COLON != null) ? tDOUBLE_COLON : (tDOUBLE_COLON = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "DOUBLE_COLON"));
+ }
+
+ //terminal SHIFT:
+ // "<<" | ">>";
+ public TerminalRule getSHIFTRule() {
+ return (tSHIFT != null) ? tSHIFT : (tSHIFT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "SHIFT"));
+ }
+
+ //terminal BOUND_FUNC_ARROW:
+ // "=>";
+ public TerminalRule getBOUND_FUNC_ARROWRule() {
+ return (tBOUND_FUNC_ARROW != null) ? tBOUND_FUNC_ARROW : (tBOUND_FUNC_ARROW = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "BOUND_FUNC_ARROW"));
+ }
+
+ //terminal FUNC_ARROW:
+ // "->";
+ public TerminalRule getFUNC_ARROWRule() {
+ return (tFUNC_ARROW != null) ? tFUNC_ARROW : (tFUNC_ARROW = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "FUNC_ARROW"));
+ }
+
+ //terminal COMPARE:
+ // "<" | "==" | ">" | "<=" | ">=" | "!=";
+ public TerminalRule getCOMPARERule() {
+ return (tCOMPARE != null) ? tCOMPARE : (tCOMPARE = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "COMPARE"));
+ }
+
+ //terminal COMPOUND_ASSIGN:
+ // "+=" | "-=";
+ public TerminalRule getCOMPOUND_ASSIGNRule() {
+ return (tCOMPOUND_ASSIGN != null) ? tCOMPOUND_ASSIGN : (tCOMPOUND_ASSIGN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "COMPOUND_ASSIGN"));
+ }
+
+ //terminal PLUS_PLUS:
+ // "++";
+ public TerminalRule getPLUS_PLUSRule() {
+ return (tPLUS_PLUS != null) ? tPLUS_PLUS : (tPLUS_PLUS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "PLUS_PLUS"));
+ }
+
+ //terminal MINUS_MINUS:
+ // "--";
+ public TerminalRule getMINUS_MINUSRule() {
+ return (tMINUS_MINUS != null) ? tMINUS_MINUS : (tMINUS_MINUS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "MINUS_MINUS"));
+ }
+
+ //terminal PARAM_END:
+ // "**)";
+ public TerminalRule getPARAM_ENDRule() {
+ return (tPARAM_END != null) ? tPARAM_END : (tPARAM_END = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "PARAM_END"));
+ }
+
+ //terminal PARAM_START:
+ // "(**";
+ public TerminalRule getPARAM_STARTRule() {
+ return (tPARAM_START != null) ? tPARAM_START : (tPARAM_START = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "PARAM_START"));
+ }
+
+ //terminal AT_SIGIL:
+ // "@";
+ public TerminalRule getAT_SIGILRule() {
+ return (tAT_SIGIL != null) ? tAT_SIGIL : (tAT_SIGIL = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "AT_SIGIL"));
+ }
+
+ //terminal BOOL:
+ // "true" | "false" | "undefined" | "null" | "on" | "no" | "yes" | "off";
+ public TerminalRule getBOOLRule() {
+ return (tBOOL != null) ? tBOOL : (tBOOL = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "BOOL"));
+ }
+
+ //terminal BY:
+ // "by";
+ public TerminalRule getBYRule() {
+ return (tBY != null) ? tBY : (tBY = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "BY"));
+ }
+
+ //terminal CALL_END:
+ // "*)";
+ public TerminalRule getCALL_ENDRule() {
+ return (tCALL_END != null) ? tCALL_END : (tCALL_END = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "CALL_END"));
+ }
+
+ //terminal CALL_START:
+ // "(*";
+ public TerminalRule getCALL_STARTRule() {
+ return (tCALL_START != null) ? tCALL_START : (tCALL_START = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "CALL_START"));
+ }
+
+ //terminal CATCH:
+ // "catch";
+ public TerminalRule getCATCHRule() {
+ return (tCATCH != null) ? tCATCH : (tCATCH = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "CATCH"));
+ }
+
+ //terminal CLASS:
+ // "class";
+ public TerminalRule getCLASSRule() {
+ return (tCLASS != null) ? tCLASS : (tCLASS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "CLASS"));
+ }
+
+ //terminal COLON:
+ // ":";
+ public TerminalRule getCOLONRule() {
+ return (tCOLON != null) ? tCOLON : (tCOLON = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "COLON"));
+ }
+
+ //terminal COLON_SLASH:
+ // "dummy COLON_SLASH";
+ public TerminalRule getCOLON_SLASHRule() {
+ return (tCOLON_SLASH != null) ? tCOLON_SLASH : (tCOLON_SLASH = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "COLON_SLASH"));
+ }
+
+ //terminal COMMA:
+ // ",";
+ public TerminalRule getCOMMARule() {
+ return (tCOMMA != null) ? tCOMMA : (tCOMMA = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "COMMA"));
+ }
+
+ //terminal DOT:
+ // ".";
+ public TerminalRule getDOTRule() {
+ return (tDOT != null) ? tDOT : (tDOT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "DOT"));
+ }
+
+ //terminal ELSE:
+ // "else";
+ public TerminalRule getELSERule() {
+ return (tELSE != null) ? tELSE : (tELSE = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "ELSE"));
+ }
+
+ //terminal EQUAL:
+ // "=";
+ public TerminalRule getEQUALRule() {
+ return (tEQUAL != null) ? tEQUAL : (tEQUAL = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "EQUAL"));
+ }
+
+ //terminal EXTENDS:
+ // "extends";
+ public TerminalRule getEXTENDSRule() {
+ return (tEXTENDS != null) ? tEXTENDS : (tEXTENDS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "EXTENDS"));
+ }
+
+ //terminal FINALLY:
+ // "finally";
+ public TerminalRule getFINALLYRule() {
+ return (tFINALLY != null) ? tFINALLY : (tFINALLY = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "FINALLY"));
+ }
+
+ //terminal FOR:
+ // "for";
+ public TerminalRule getFORRule() {
+ return (tFOR != null) ? tFOR : (tFOR = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "FOR"));
+ }
+
+ //terminal FORIN:
+ // "in";
+ public TerminalRule getFORINRule() {
+ return (tFORIN != null) ? tFORIN : (tFORIN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "FORIN"));
+ }
+
+ //terminal FOROF:
+ // "of";
+ public TerminalRule getFOROFRule() {
+ return (tFOROF != null) ? tFOROF : (tFOROF = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "FOROF"));
+ }
+
+ //terminal FUNC_EXIST:
+ // "dummy FUNC_EXIST";
+ public TerminalRule getFUNC_EXISTRule() {
+ return (tFUNC_EXIST != null) ? tFUNC_EXIST : (tFUNC_EXIST = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "FUNC_EXIST"));
+ }
+
+ //terminal HERECOMMENT:
+ // "dummy HERECOMMENT";
+ public TerminalRule getHERECOMMENTRule() {
+ return (tHERECOMMENT != null) ? tHERECOMMENT : (tHERECOMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "HERECOMMENT"));
+ }
+
+ //terminal IF:
+ // "if" | "unless";
+ public TerminalRule getIFRule() {
+ return (tIF != null) ? tIF : (tIF = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "IF"));
+ }
+
+ //terminal INDENT:
+ // "{*";
+ public TerminalRule getINDENTRule() {
+ return (tINDENT != null) ? tINDENT : (tINDENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "INDENT"));
+ }
+
+ //terminal INDEX_END:
+ // "*]";
+ public TerminalRule getINDEX_ENDRule() {
+ return (tINDEX_END != null) ? tINDEX_END : (tINDEX_END = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "INDEX_END"));
+ }
+
+ //terminal INDEX_PROTO:
+ // "dummy INDEX_PROTO";
+ public TerminalRule getINDEX_PROTORule() {
+ return (tINDEX_PROTO != null) ? tINDEX_PROTO : (tINDEX_PROTO = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "INDEX_PROTO"));
+ }
+
+ //terminal INDEX_SOAK:
+ // "dummy INDEX_SOAK";
+ public TerminalRule getINDEX_SOAKRule() {
+ return (tINDEX_SOAK != null) ? tINDEX_SOAK : (tINDEX_SOAK = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "INDEX_SOAK"));
+ }
+
+ //terminal INDEX_START:
+ // "[*";
+ public TerminalRule getINDEX_STARTRule() {
+ return (tINDEX_START != null) ? tINDEX_START : (tINDEX_START = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "INDEX_START"));
+ }
+
+ //terminal JS:
+ // "dummy JS";
+ public TerminalRule getJSRule() {
+ return (tJS != null) ? tJS : (tJS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "JS"));
+ }
+
+ //terminal LBRACKET:
+ // "[";
+ public TerminalRule getLBRACKETRule() {
+ return (tLBRACKET != null) ? tLBRACKET : (tLBRACKET = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "LBRACKET"));
+ }
+
+ //terminal LCURLY:
+ // "dummy LCURLY";
+ public TerminalRule getLCURLYRule() {
+ return (tLCURLY != null) ? tLCURLY : (tLCURLY = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "LCURLY"));
+ }
+
+ //terminal LEADING_WHEN:
+ // "dummy LEADING_WHEN";
+ public TerminalRule getLEADING_WHENRule() {
+ return (tLEADING_WHEN != null) ? tLEADING_WHEN : (tLEADING_WHEN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "LEADING_WHEN"));
+ }
+
+ //terminal LOGIC:
+ // "&&" | "||";
+ public TerminalRule getLOGICRule() {
+ return (tLOGIC != null) ? tLOGIC : (tLOGIC = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "LOGIC"));
+ }
+
+ //terminal LOOP:
+ // "loop";
+ public TerminalRule getLOOPRule() {
+ return (tLOOP != null) ? tLOOP : (tLOOP = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "LOOP"));
+ }
+
+ //terminal LPAREN:
+ // "(";
+ public TerminalRule getLPARENRule() {
+ return (tLPAREN != null) ? tLPAREN : (tLPAREN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "LPAREN"));
+ }
+
+ //terminal MATH:
+ // "*" | "/";
+ public TerminalRule getMATHRule() {
+ return (tMATH != null) ? tMATH : (tMATH = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "MATH"));
+ }
+
+ //terminal MINUS:
+ // "-";
+ public TerminalRule getMINUSRule() {
+ return (tMINUS != null) ? tMINUS : (tMINUS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "MINUS"));
+ }
+
+ //terminal NEW:
+ // "new";
+ public TerminalRule getNEWRule() {
+ return (tNEW != null) ? tNEW : (tNEW = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "NEW"));
+ }
+
+ //terminal NUMBER returns ecore::EInt:
+ // "0".."9"+;
+ public TerminalRule getNUMBERRule() {
+ return (tNUMBER != null) ? tNUMBER : (tNUMBER = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "NUMBER"));
+ }
+
+ //terminal OUTDENT:
+ // "*}";
+ public TerminalRule getOUTDENTRule() {
+ return (tOUTDENT != null) ? tOUTDENT : (tOUTDENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "OUTDENT"));
+ }
+
+ //terminal OWN:
+ // "own";
+ public TerminalRule getOWNRule() {
+ return (tOWN != null) ? tOWN : (tOWN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "OWN"));
+ }
+
+ //terminal PLUS:
+ // "+";
+ public TerminalRule getPLUSRule() {
+ return (tPLUS != null) ? tPLUS : (tPLUS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "PLUS"));
+ }
+
+ //// practically the same as IF
+ //terminal POST_IF:
+ // "dummy POST_IF";
+ public TerminalRule getPOST_IFRule() {
+ return (tPOST_IF != null) ? tPOST_IF : (tPOST_IF = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "POST_IF"));
+ }
+
+ //terminal QUESTION:
+ // "?";
+ public TerminalRule getQUESTIONRule() {
+ return (tQUESTION != null) ? tQUESTION : (tQUESTION = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "QUESTION"));
+ }
+
+ //terminal QUESTION_DOT:
+ // "?.";
+ public TerminalRule getQUESTION_DOTRule() {
+ return (tQUESTION_DOT != null) ? tQUESTION_DOT : (tQUESTION_DOT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "QUESTION_DOT"));
+ }
+
+ //terminal RBRACKET:
+ // "]";
+ public TerminalRule getRBRACKETRule() {
+ return (tRBRACKET != null) ? tRBRACKET : (tRBRACKET = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "RBRACKET"));
+ }
+
+ //terminal RCURLY:
+ // "dummy RCURLY";
+ public TerminalRule getRCURLYRule() {
+ return (tRCURLY != null) ? tRCURLY : (tRCURLY = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "RCURLY"));
+ }
+
+ //terminal REGEX:
+ // "///"->"///";
+ public TerminalRule getREGEXRule() {
+ return (tREGEX != null) ? tREGEX : (tREGEX = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "REGEX"));
+ }
+
+ //terminal RELATION:
+ // "in" | "of" | "instanceof";
+ public TerminalRule getRELATIONRule() {
+ return (tRELATION != null) ? tRELATION : (tRELATION = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "RELATION"));
+ }
+
+ //terminal RETURN:
+ // "return";
+ public TerminalRule getRETURNRule() {
+ return (tRETURN != null) ? tRETURN : (tRETURN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "RETURN"));
+ }
+
+ //terminal RPAREN:
+ // ")";
+ public TerminalRule getRPARENRule() {
+ return (tRPAREN != null) ? tRPAREN : (tRPAREN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "RPAREN"));
+ }
+
+ //terminal STATEMENT:
+ // "break" | "continue" | "debugger";
+ public TerminalRule getSTATEMENTRule() {
+ return (tSTATEMENT != null) ? tSTATEMENT : (tSTATEMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "STATEMENT"));
+ }
+
+ //terminal STRING:
+ // "\'\'\'"->"\'\'\'" | "\'" (!"\'" ("\\" ("b" | "t" | "n" | "f" | "r" | "u" | "\"" | "\'" | "\\") | !("\\" | "\'"))*)?
+ // "\'" | "\"\"\""->"\"\"\"" | "\"" (!"\"" ("\\" ("b" | "t" | "n" | "f" | "r" | "u" | "\"" | "\'" | "\\") | !("\\" |
+ // "\""))*)? "\"";
+ public TerminalRule getSTRINGRule() {
+ return (tSTRING != null) ? tSTRING : (tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "STRING"));
+ }
+
+ //terminal SUPER:
+ // "super";
+ public TerminalRule getSUPERRule() {
+ return (tSUPER != null) ? tSUPER : (tSUPER = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "SUPER"));
+ }
+
+ //terminal SWITCH:
+ // "switch";
+ public TerminalRule getSWITCHRule() {
+ return (tSWITCH != null) ? tSWITCH : (tSWITCH = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "SWITCH"));
+ }
+
+ //terminal TERMINATOR:
+ // "\n"+;
+ public TerminalRule getTERMINATORRule() {
+ return (tTERMINATOR != null) ? tTERMINATOR : (tTERMINATOR = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "TERMINATOR"));
+ }
+
+ //terminal THEN:
+ // "then";
+ public TerminalRule getTHENRule() {
+ return (tTHEN != null) ? tTHEN : (tTHEN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "THEN"));
+ }
+
+ //terminal THIS:
+ // "this";
+ public TerminalRule getTHISRule() {
+ return (tTHIS != null) ? tTHIS : (tTHIS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "THIS"));
+ }
+
+ //terminal THROW:
+ // "throw";
+ public TerminalRule getTHROWRule() {
+ return (tTHROW != null) ? tTHROW : (tTHROW = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "THROW"));
+ }
+
+ //terminal TRY:
+ // "try";
+ public TerminalRule getTRYRule() {
+ return (tTRY != null) ? tTRY : (tTRY = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "TRY"));
+ }
+
+ //terminal UNARY:
+ // "!" | "~";
+ public TerminalRule getUNARYRule() {
+ return (tUNARY != null) ? tUNARY : (tUNARY = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "UNARY"));
+ }
+
+ //terminal UNTIL:
+ // "until";
+ public TerminalRule getUNTILRule() {
+ return (tUNTIL != null) ? tUNTIL : (tUNTIL = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "UNTIL"));
+ }
+
+ //terminal WHEN:
+ // "when";
+ public TerminalRule getWHENRule() {
+ return (tWHEN != null) ? tWHEN : (tWHEN = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "WHEN"));
+ }
+
+ //terminal WHILE:
+ // "while";
+ public TerminalRule getWHILERule() {
+ return (tWHILE != null) ? tWHILE : (tWHILE = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "WHILE"));
+ }
+
+ //// These tokens are used only by syntax coloring
+ //terminal LOGIC_WORD:
+ // "and" | "or";
+ public TerminalRule getLOGIC_WORDRule() {
+ return (tLOGIC_WORD != null) ? tLOGIC_WORD : (tLOGIC_WORD = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "LOGIC_WORD"));
+ }
+
+ //terminal COMPARE_WORD:
+ // "isnt" | "is";
+ public TerminalRule getCOMPARE_WORDRule() {
+ return (tCOMPARE_WORD != null) ? tCOMPARE_WORD : (tCOMPARE_WORD = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "COMPARE_WORD"));
+ }
+
+ //terminal UNARY_WORD:
+ // "new" | "do" | "not";
+ public TerminalRule getUNARY_WORDRule() {
+ return (tUNARY_WORD != null) ? tUNARY_WORD : (tUNARY_WORD = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "UNARY_WORD"));
+ }
+
+ //terminal ML_COMMENT:
+ // "###" !"#"->"###";
+ public TerminalRule getML_COMMENTRule() {
+ return (tML_COMMENT != null) ? tML_COMMENT : (tML_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "ML_COMMENT"));
+ }
+
+ //terminal SL_COMMENT:
+ // "#" !("\n" | "\r")* ("\r"? "\n")?;
+ public TerminalRule getSL_COMMENTRule() {
+ return (tSL_COMMENT != null) ? tSL_COMMENT : (tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "SL_COMMENT"));
+ }
+
+ //terminal WS:
+ // (" " | "\t")+;
+ public TerminalRule getWSRule() {
+ return (tWS != null) ? tWS : (tWS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "WS"));
+ }
+
+ //// Put it at the end, so keywords will be matched earlier
+ //// }}} end of terminals
+ //// vim: set fdm=marker:
+ //terminal IDENTIFIER:
+ // "^"? ("a".."z" | "A".."Z" | "_") ("a".."z" | "A".."Z" | "_" | "0".."9")*;
+ public TerminalRule getIDENTIFIERRule() {
+ return (tIDENTIFIER != null) ? tIDENTIFIER : (tIDENTIFIER = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "IDENTIFIER"));
+ }
+}
diff --git a/csep/src-gen/csep/validation/AbstractCoffeeScriptJavaValidator.java b/csep/src-gen/csep/validation/AbstractCoffeeScriptJavaValidator.java
new file mode 100644
index 0000000..f7d0aeb
--- /dev/null
+++ b/csep/src-gen/csep/validation/AbstractCoffeeScriptJavaValidator.java
@@ -0,0 +1,22 @@
+/*
+* generated by Xtext
+*/
+package csep.validation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.xtext.validation.ComposedChecks;
+
+@ComposedChecks(validators= {org.eclipse.xtext.validation.ImportUriValidator.class})
+public class AbstractCoffeeScriptJavaValidator extends org.eclipse.xtext.validation.AbstractDeclarativeValidator {
+
+ @Override
+ protected List getEPackages() {
+ List result = new ArrayList();
+ result.add(csep.coffeeScript.CoffeeScriptPackage.eINSTANCE);
+ return result;
+ }
+
+}
diff --git a/csep/xtend-gen/csep/generator/.CoffeeScriptGenerator.java._trace b/csep/xtend-gen/csep/generator/.CoffeeScriptGenerator.java._trace
new file mode 100644
index 0000000..6f60316
Binary files /dev/null and b/csep/xtend-gen/csep/generator/.CoffeeScriptGenerator.java._trace differ
diff --git a/csep/xtend-gen/csep/generator/CoffeeScriptGenerator.java b/csep/xtend-gen/csep/generator/CoffeeScriptGenerator.java
new file mode 100644
index 0000000..e2a9429
--- /dev/null
+++ b/csep/xtend-gen/csep/generator/CoffeeScriptGenerator.java
@@ -0,0 +1,14 @@
+/**
+ * generated by Xtext
+ */
+package csep.generator;
+
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.generator.IFileSystemAccess;
+import org.eclipse.xtext.generator.IGenerator;
+
+@SuppressWarnings("all")
+public class CoffeeScriptGenerator implements IGenerator {
+ public void doGenerate(final Resource resource, final IFileSystemAccess fsa) {
+ }
+}
diff --git a/devjournal.md b/devjournal.md
index 793c7bc..9c80d71 100644
--- a/devjournal.md
+++ b/devjournal.md
@@ -1,5 +1,11 @@
-# Display parse tree for debugging purposes
+# Dev Journal
+
+Started by Adam Schmideg
+
+## part 1
+
+### Display parse tree for debugging purposes
- Trying [Implement toString with Xtext's Serializer][1].
The parse tree I get is flat without indentation when not doing the `toString` replacement magic,
@@ -11,25 +17,25 @@
The serializer approach doesn't work, because [it's supposed to output a parseable string][2]
- Done. See `csep.parser.Helper.stringify`.
-# Overriding `nextToken()` in Lexer is not enough.
+### Overriding `nextToken()` in Lexer is not enough.
The parser seems to use only the first token when building the AST.
- There are some differences between the token returned by the internal lexer and the token by the aptana lexer.
The differences include: whitespace handling; EOF; type/id of operators.
- The difference of whitespace and EOF handling seem to cause no problem.
-# Why is the type of operators different in BeaverToken?
+### Why is the type of operators different in BeaverToken?
- A literal '+' within a rule is not the same as using PLUS within the same rule.
(Note: the aptana lexer returns a MATH token both for '\*' and for '/')
-# How to vizualize the LALR grammar of coffeescript?
+### How to vizualize the LALR grammar of coffeescript?
- I asked about [visualizing LALR grammar] on Stackoverflow
- I found [GOLD parser][4] which has an IDE, but runs only on Windows.
But I may check it out.
-# Learning ANTLR
+### Learning ANTLR
* Tried to use the generated python target, but it seemed difficult on
Ubuntu: there is no python binding for antlr3, the java version
@@ -49,7 +55,7 @@
right-hand side of `expression`.
* I'm not sure how close I can stay to the original LR grammar.
-# Convert Antlr grammar to Xtext
+### Convert Antlr grammar to Xtext
See [Convert Antlr grammar to Xtext][6]
@@ -66,25 +72,25 @@ See [Convert Antlr grammar to Xtext][6]
* Optionally you may want to capitalize the rule names to follow the
java convention.
-# Running headless with make
+### Running headless with make
- * I'm going to abandod this because eclipse packages are versioned with a build date too which is difficult to handle in a Makefile.
+ * I'm going to abandon this because eclipse packages are versioned with a build date too which is difficult to handle in a Makefile.
* Possible (and time-consuming) solutions are
* use some dependency management tool, such as ivy
* do some bash scripting magic to find foo-[version]-v[build-date].jar and copy it as foo-[version].jar
-# Terminals in a separate file.
+### Terminals in a separate file.
Well, [I've struggled with it][7]. Abandoned, it's not worth the effort.
-# Partial parsing instead of failure
+### Partial parsing instead of failure
`1 = 2` should fail, but it the first token gets parsed, the rest discarded without any error message.
Done, using `org.eclipse.xtext.junit.AbstractXtextTests.getModelAndExpect()`
-# How is THEN handled?
+### How is THEN handled?
Fortunately, it seems to be handled by the lexer, making it a block
-# Add postfix conditional.
+### Add postfix conditional.
The problem is "num = 2 if even" is parsed as an assignment "num = 2", then the next IF token is considered an error.
It may be handled the same way as the existence operator.
@@ -108,7 +114,7 @@ I don't know why unary expression is included in the chain, and not in the Prima
The referrred `[Class]` will not create a new class name, but expects an existing name
* Syntactic predicate denoted as `=>`.
-# Debugging Xtext grammar with Antlrworks
+### Debugging Xtext grammar with Antlrworks
* The grammar generated doesn't compile, it's looking for a class
`DebugAbstractInternalAntlrParser` which cannot be found anywhere
@@ -120,7 +126,7 @@ I don't know why unary expression is included in the chain, and not in the Prima
gets generated which can be opened and debugged with Antlrworks
seamlessly
-# Warning: "Decision can match input such as RULE\_IF using multiple alternatives: 1, 2"
+### Warning: "Decision can match input such as RULE\_IF using multiple alternatives: 1, 2"
* Before the previous commit it almost disappeared, then it came back.
* The answer to this [Stackoverflow question][9] says, you can set
@@ -135,7 +141,7 @@ I don't know why unary expression is included in the chain, and not in the Prima
I don't know how to achieve this in the Xtext grammar.
I don't know why this fixes the Antlr grammar, either.
-# Handle dynamic variables.
+### Handle dynamic variables.
It's more difficult than it first seemed, see [my Stackoverflow question about handling dynamic variables][10]
* There is a difference between the generated debug grammar and the
@@ -164,7 +170,7 @@ It's more difficult than it first seemed, see [my Stackoverflow question about h
Unfortunately, it gives the same non-LL(\*) decision error.
-# Linking.
+### Linking.
Introduced `IdRef` and a dummy scoping mechanism.
It shuts up linking problems and enables most coffeescript constructs.
The only drawback for the moment seems to be that variables cannot be reassigned.
@@ -175,7 +181,7 @@ and http://zarnekow.blogspot.com/2010/06/customizing-error-messages-in-xtext-10.
* Testing with automatically generated sentences fed to `coffee`
See my question: http://stackoverflow.com/questions/8478320/generate-syntactically-correct-sentences-from-an-antlr-grammar
-# Syntax highlight of keywords.
+### Syntax highlight of keywords.
It should be automatic, but it matters how terminals are defined in
the grammar, consider this:
@@ -193,14 +199,14 @@ This is what I just started.
`Regex` can be configured in the preferences now, but it doesn't get
highlighted in the source code.
-# Tricky highlight issues
+### Tricky highlight issues
- how to handle 'then' which doesn't get a token, but is replaced with
a block?
- how to handle string interpolation? `"before #{ x } after"` is
tokenized as `[( (] [STRING "before "] [+ +] [IDENTIFIER x] [+ +] [STRING " after"] [) )]`
-# Variable scoping. The strategy is
+### Variable scoping. The strategy is
- The left-hand side of assignment contains `Id`.
It causes a `Duplicate ForValue` error in case of reassignment.
@@ -215,7 +221,7 @@ highlighted in the source code.
It wouldn't accept syntactically correct, but erroneous
expressions, such as `[a+1] = 3`
-# Syntax highlight of comments
+### Syntax highlight of comments
Xtext uses `TokenScanner` when doing syntax highlighting which seems
to ignore the lexer and to use the xtext grammar directly.
I asked about it: http://www.eclipse.org/forums/index.php/m/772060/#msg\_772060
@@ -224,7 +230,7 @@ I may check out semantic highlighting instead.
It was easier to change the terminals in the xtext grammar and stay
with the current lexical highlighter.
-# Display tokenization errors correctly.
+### Display tokenization errors correctly.
An exception may be thrown either by the scanner, or by the rewriter.
In the first case, we have a stream of valid tokens up to the point
where the exception was thrown.
@@ -238,7 +244,7 @@ XtextResource.
The errors in XtextResource are cleared in the parsing phase, so
adding a Diagnostic error by the lexer would be lost.
-# Issues
+### Issues
- One-character long string not recognized in editor -- Done
- Double quotation mark within singly quoted string -- Done
@@ -254,9 +260,9 @@ adding a Diagnostic error by the lexer would be lost.
- Use `.coffee` as file extension -- Done
- Accept empty file
-# The file has to be modified to activate xtext grammar check
+### The file has to be modified to activate xtext grammar check
-# Problems with tokens got from Aptana scanner
+### Problems with tokens got from Aptana scanner
- It uses short numbers internally which easily overflows, resulting
token positions restarted after 4095 -- oops, not true, it simply
@@ -268,7 +274,7 @@ adding a Diagnostic error by the lexer would be lost.
- It doesn't seem to keep track of line number and positions within
line
-# The case of the ugly StringIndexOutOfBoundsException:
+### The case of the ugly StringIndexOutOfBoundsException:
When an issue is raised, its content is calculated from the whole
text indexed by the token where occurred.
But the whole text is calculated by taking the input char stream and
@@ -277,7 +283,7 @@ adding a Diagnostic error by the lexer would be lost.
and we'll get a shorter full text.
So a substring with the proper indexes will fail.
-# Most annoying issue:
+### Most annoying issue:
The editor works inconsistently.
- Sometimes `No viable alternative at EOF` for an empty or almost
@@ -286,9 +292,9 @@ adding a Diagnostic error by the lexer would be lost.
- Saving a file removes warnings
- The warnings are not shown in the `Problems` window
-# Hovering sometimes throws an NPE, maybe when I hover over a missing crossref
+### Hovering sometimes throws an NPE, maybe when I hover over a missing crossref
-# Scoping, second round.
+### Scoping, second round.
Reading this series of posts: http://blogs.itemis.de/stundzig/archives/773
I just realized that functions have dynamic scoping, but loops seem to
have lexical scoping.
@@ -323,18 +329,18 @@ Probably interdependent issues
- Saving or modifying a file may change whether or not problems are
shown in the editor
-# An ugly bug that took me hours to hunt down
+### An ugly bug that took me hours to hunt down
When there's an error in the file, any change to the file will generate a number of errors without any message.
This is due to the bug that somewhere deep down trailing zero bytes are appended to the source text to be parsed.
My hunch is it's related to replacing the text from the previous parse result using a replace region.
I couldn't find the exact source of the problem, but could make a simple workaround.
-# Auto-completion
+### Auto-completion
The tricky thing is: when we try to give a completion for `Math.`,
the context is an IdRef, but it can't find any referee named `Math`.
So we have no name for the lookup.
-# String interpolation mystery
+### String interpolation mystery
The right-hand side of `first` and `second` in the following snippet should be parsed the same,
because the same tokens are generated.
@@ -345,7 +351,7 @@ because the same tokens are generated.
But in the second case, a warning is given that the reference cannot be found.
There is also an offset problem here, the warning message is `Couldn't resolve reference to Id '#{na'`
-# Annoying editor bug
+### Annoying editor bug
This is how I could reproduce a problem most of the times (it may depend on typing speed).
Enter the following snippet into an empty file
@@ -370,9 +376,9 @@ The result is: when the underlying parser gets the whole stream as string,
A related problem is that the scanner added and removed some whitespaces to make its job easier,
but it didn't fix the offsets accordingly.
-# Respond to bug reports.
+### Respond to bug reports.
-# Resolution warning. The minimal snippet to reproduce it is
+### Resolution warning. The minimal snippet to reproduce it is
a = 1
#remark
@@ -388,13 +394,13 @@ Parse element with wrong offsets are produced in `XtextResource.update` after ca
Workaround: don't use partialParser, because it seems to be responsible for the wrong offsets.
This may result in some performance penalty for larger files.
-# Asked about issues at Eclipse forum
+### Asked about issues at Eclipse forum
- [Debug grammar generation gives error but seems to work](http://www.eclipse.org/forums/index.php/m/791928/)
- [Partial parsing can't resolve some references](http://www.eclipse.org/forums/index.php/m/791944/)
- I got some answers -- or clarifying questions rather that I replied to.
-# Installable plugin
+### Installable plugin
I followed the instructions on
[How to create an update site](http://wiki.eclipse.org/FAQ_How_do_I_create_an_update_site_\(site.xml\)%3F)
Now all you have to do is
@@ -406,15 +412,15 @@ Now all you have to do is
The `csep.update` directory will be populated with the required artifacts.
-# Directories are cleaned by `org.eclipse.emf.mwe.utils.DirectoryCleaner` before generating source
+### Directories are cleaned by `org.eclipse.emf.mwe.utils.DirectoryCleaner` before generating source
The cleaner ignores `.csvignore` files by default, so I put such files into `xxx-gen` folders
as a workaround to have empty directories (not tracked by mercurial).
-# This whole plugin development with xtext looks a pile of undocumented, overcomplicated crap
+### This whole plugin development with xtext looks a pile of undocumented, overcomplicated crap
My question is http://www.eclipse.org/forums/index.php/m/795597/
-# Eclipse plugin versioning.
+### Eclipse plugin versioning.
I want to append date to version number automatically.
It would make plugin development easier: no need to remove and reinstall it, just update it.
@@ -433,14 +439,14 @@ It will keep the commited site.xml file intact from timestamps.
Asked http://stackoverflow.com/questions/9535064/
-# Problem with generated folders again
+### Problem with generated folders again
Eclipse gives a warning "the resource is a duplicate of ..."
I added some comment to the `.csvignore` files causing the problem -- no change.
I followed the advice of http://www.stevenmarkford.com/solution-to-eclipse-warning-with-svn-the-resource-is-a-duplicate-of-and-was-not-copied-to-the-output-folder/
-- no change.
Leaving it as is, for now.
-# Update site
+### Update site
It's difficult to find a hosting site, because download folders are required.
Most open source hosting sites don't provide this.
The only exception may be Sourceforge, but I haven't checked it, I don't want to register.
@@ -464,7 +470,7 @@ It has no ability to create download directories, either, so I'll have to put it
[11]: http://stackoverflow.com/questions/8438755/stripping-actions-from-antlr-grammar-changes-its-parsing-algorithm
[12]: http://antlrv3ide.sourceforge.net/
-# Create a coffee plugin so the language can be extended
+### Create a coffee plugin so the language can be extended
Cakefile language is almost the same as coffee with a single addition: it has `task` as a predefined function.
It requires two steps to make it work
@@ -523,7 +529,7 @@ It seems to fix the problem, the coffeescript genmodel is now registered correct
[xbase]: http://dev.eclipse.org/viewcvs/viewvc.cgi/org.eclipse.tmf/org.eclipse.xtext/plugins/org.eclipse.xtext.xbase/?root=Modeling_Project
[xtext_faq]: http://wiki.eclipse.org/Xtext/FAQ#How_do_I_load_my_model_in_a_standalone_Java_application.C2.A0.3F
-# Some warnings probably not to be fixed
+### Some warnings probably not to be fixed
"Discouraged access: The type CoffeeScriptActivator is not accessible due to restriction on required project csep.ui" in
in `csep.tests/src-gen/csep/CoffeeScriptUiInjectorProvider.java`
It's generated code, I don't know how to fix it.
@@ -546,7 +552,7 @@ One warning I fixed: Java execution environment warning.
- Right click on `JRE System Library` in the package explorer
- Select `JavaSE-1.6` from the options
-# Serialization
+### Serialization
My hunch is that the issue https://bitbucket.org/adamschmideg/coffeescript-eclipse/issue/7 is related to serialization.
Partly, because a NPE is involved.
If I omit serialization from the mwe2 workflow, the generation works fine, but the above issue is present.
@@ -554,7 +560,7 @@ If I I have serialization in the workflow, it writes an error: "constraint is IN
(it's written by `org.eclipse.xtext.serializer.analysis.GrammarConstraintProvider.getConstraints`).
If I even set `generateDebugData` in it, a NPE is thrown.
-# Use coffee lexer for cakefile
+### Use coffee lexer for cakefile
The generated tokens seem to have a different integer value for coffee and cakefile.
I implemented a mindless mapping, see `csep.example.cake.parser.TokenTypeMapper`.
It maps between coffee and cakefile tokens (both used in different cases).
@@ -562,21 +568,21 @@ It maps between coffee and cakefile tokens (both used in different cases).
Map grammar-specific identifiers ('task' in this case) are mapped to an appropriate terminal rule by
`csep.example.cake.parser.CustomLexer.nextToken`
-# Implicit parameter
+### Implicit parameter
I want to use options either explicitly, or implicitly:
- # Implicit
+ ### Implicit
task "foo", "desc", ->
- # OK, implicit variable
+ ### OK, implicit variable
options.foo
- # Invalid, reference to unknown variable
+ ### Invalid, reference to unknown variable
opts.foo
- # Explicit
+ ### Explicit
task "foo", "desc", (opts) ->
- # OK
+ ### OK
opts.foo
- # Invalid when options provided explicitly
+ ### Invalid when options provided explicitly
options.foo
I'm not even sure if these links are relevant
@@ -584,7 +590,7 @@ I'm not even sure if these links are relevant
- https://bugs.eclipse.org/bugs/show\_bug.cgi?id=326298
- http://www.eclipse.org/Xtext/documentation/2\_0\_0/020-grammar-language.php#customPostProcessing
-## Change generated constructor in postprocessing
+#### Change generated constructor in postprocessing
Not sure if it works, this phase may come later than scoping/linking.
Anyway, I'm trying to change the constructor of `TaskDeclaration` to give a default value to `options`.
Some examples
@@ -594,7 +600,7 @@ Some examples
Well, the postprocessing approach probably wouldn't work, because it doesn't take care of scoping.
-## Custom scoping
+#### Custom scoping
I added custom declarative scoping.
I have two problems with it
@@ -604,19 +610,19 @@ I have two problems with it
- What scope should I return for an implicit variable?
My question at the Eclipse forum: http://www.eclipse.org/forums/index.php/mv/msg/309869/821018/#msg_821018
-## Consecutive assignments as nested scopes
+#### Consecutive assignments as nested scopes
This would handle re-assignment correctly.
- a = 1 # scope 1
- b = 2 # scope 2
- doSomething() # same scope as before
- a = a + 1 # new scope shadowing variable `a`
- useVar(a) # same scope as before, using re-assigned `a`
+ a = 1 ### scope 1
+ b = 2 ### scope 2
+ doSomething() ### same scope as before
+ a = a + 1 ### new scope shadowing variable `a`
+ useVar(a) ### same scope as before, using re-assigned `a`
This may more elegant than the way it's currently implemented,
but it can wait.
-## Error in editor: \ contains a dangling reference
+#### Error in editor: \ contains a dangling reference
I implemented custom scoping.
Now the above error is shown only in the editor, but the test case with implicit variable runs without any problem.
I realized that `scope\_Id` method doesn't have to know the name of the id.
@@ -648,22 +654,48 @@ So I choose to override `updateInternalState` and add implicit variables to the
This last approach seems to work.
-# Include source in plugin bundle
+### Include source in plugin bundle
There seems to be two ways to do it, but none of them works for me:
- http://help.eclipse.org/indigo/index.jsp?topic=%2Forg.eclipse.pde.doc.user%2Ftasks%2Fpde\_individual\_source.htm
- http://wiki.eclipse.org/PDEBuild/Individual\_Source\_Bundles
-# Timestamp issue
+### Timestamp issue
See https://bitbucket.org/adamschmideg/coffeescript-eclipse/issue/6
It's caused by the missing `last-modified` entry in the http header returned by the googlecode mercurial front-end.
Set to `wontfix`.
-# Use branches on github
+### Use branches on github
I don't see an easy way to convert hg branches to git branches.
It would involve creating a hg bookmark for each hg branch which is otherwise discouraged.
So I'm going to use a single master branch on github until a better solution is found.
-# Markdown in README
+### Markdown in README
Bitbucket uses `python-markdown` and doesn't support inline html or extensions of python-markdown.
So I can see no way to have proper definition lists in the README file.
+
+## part 2
+
+### Maven Tycho
+
+mvn -Dtycho.mode=maven org.eclipse.tycho:tycho-versions-plugin:set-version -DnewVersion=NEW_VERSION-SNAPSHOT
+
+`mvn -Dtycho.mode=maven org.eclipse.tycho:tycho-versions-plugin:set-version -DnewVersion=0.4.0-SNAPSHOT`
+
+Then update `csep.site\category.xml` manually
+
+Found on [StackOverflow](http://stackoverflow.com/questions/2848687/how-to-keep-plug-in-manifest-version-and-pom-version-in-sync-in-maven-with-tycho)
+
+See also OSGi release procedures and best practices
+open as of 2013-09-01
+
+### Travis CI
+
+Setting up was straight-forward. As says:
+
+- got to
+- add simple `.travis.yml` with 1 line `language: java`, check provideIAllContainersState() {
+ return org.eclipse.xtext.ui.shared.Access.getJavaProjectsState();
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public Class bindIProposalConflictHelper() {
+ return org.eclipse.xtext.ui.editor.contentassist.antlr.AntlrProposalConflictHelper.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public void configureHighlightingLexer(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(csep.example.cake.parser.antlr.internal.InternalCakefileLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public void configureHighlightingTokenDefProvider(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.parser.antlr.ITokenDefProvider.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.exporting.QualifiedNamesFragment
+ public Class bindIDependentElementsCalculator() {
+ return org.eclipse.xtext.ui.refactoring.impl.DefaultDependentElementsCalculator.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment
+ public void configureIResourceDescriptionsBuilderScope(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.resource.IResourceDescriptions.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(org.eclipse.xtext.builder.clustering.CurrentDescriptions.ResourceSetAware.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment
+ public Class bindIXtextEditorCallback() {
+ return org.eclipse.xtext.builder.nature.NatureAddingEditorCallback.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment
+ public void configureIResourceDescriptionsPersisted(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.resource.IResourceDescriptions.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.builder.impl.PersistentDataAwareDirtyResource.PERSISTED_DESCRIPTIONS)).to(org.eclipse.xtext.builder.builderState.IBuilderState.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment
+ public Class bindDocumentBasedDirtyResource() {
+ return org.eclipse.xtext.builder.impl.PersistentDataAwareDirtyResource.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment
+ public Class bindIXtextBuilderParticipant() {
+ return org.eclipse.xtext.builder.BuilderParticipant.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment
+ public org.eclipse.core.resources.IWorkspaceRoot bindIWorkspaceRootToInstance() {
+ return org.eclipse.core.resources.ResourcesPlugin.getWorkspace().getRoot();
+ }
+
+ // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment
+ public void configureBuilderPreferenceStoreInitializer(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.ui.editor.preferences.IPreferenceStoreInitializer.class).annotatedWith(com.google.inject.name.Names.named("builderPreferenceInitializer")).to(org.eclipse.xtext.builder.preferences.BuilderPreferenceAccess.Initializer.class);
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment
+ public Class bindILabelProvider() {
+ return csep.example.cake.ui.labeling.CakefileLabelProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment
+ public void configureResourceUIServiceLabelProvider(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.jface.viewers.ILabelProvider.class).annotatedWith(org.eclipse.xtext.ui.resource.ResourceServiceDescriptionLabelProvider.class).to(csep.example.cake.ui.labeling.CakefileDescriptionLabelProvider.class);
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment
+ public Class bindIOutlineTreeProvider() {
+ return csep.example.cake.ui.outline.CakefileOutlineTreeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment
+ public Class bindIOutlineTreeStructureProvider() {
+ return csep.example.cake.ui.outline.CakefileOutlineTreeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.quickfix.QuickfixProviderFragment
+ public Class bindIssueResolutionProvider() {
+ return csep.example.cake.ui.quickfix.CakefileQuickfixProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.contentAssist.JavaBasedContentAssistFragment
+ public Class bindIContentProposalProvider() {
+ return csep.example.cake.ui.contentassist.CakefileProposalProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+ public Class bindContentAssistContext$Factory() {
+ return org.eclipse.xtext.ui.editor.contentassist.antlr.ParserBasedContentAssistContextFactory.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+ public Class bindIContentAssistParser() {
+ return csep.example.cake.ui.contentassist.antlr.CakefileParser.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+ public void configureContentAssistLexerProvider(com.google.inject.Binder binder) {
+ binder.bind(csep.example.cake.ui.contentassist.antlr.internal.InternalCakefileLexer.class).toProvider(org.eclipse.xtext.parser.antlr.LexerProvider.create(csep.example.cake.ui.contentassist.antlr.internal.InternalCakefileLexer.class));
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+ public void configureContentAssistLexer(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.CONTENT_ASSIST)).to(csep.example.cake.ui.contentassist.antlr.internal.InternalCakefileLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public java.lang.ClassLoader bindClassLoaderToInstance() {
+ return getClass().getClassLoader();
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindIJvmTypeProvider$Factory() {
+ return org.eclipse.xtext.common.types.access.jdt.JdtTypeProviderFactory.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindAbstractTypeScopeProvider() {
+ return org.eclipse.xtext.common.types.xtext.ui.JdtBasedSimpleTypeScopeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindITypesProposalProvider() {
+ return org.eclipse.xtext.common.types.xtext.ui.JdtTypesProposalProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindIJavaProjectProvider() {
+ return org.eclipse.xtext.common.types.xtext.ui.XtextResourceSetBasedProjectProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindIHyperlinkHelper() {
+ return org.eclipse.xtext.common.types.xtext.ui.TypeAwareHyperlinkHelper.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindPrefixMatcher() {
+ return org.eclipse.xtext.ui.editor.contentassist.FQNPrefixMatcher.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindAbstractJavaBasedContentProposalProvider$ReferenceProposalCreator() {
+ return org.eclipse.xtext.common.types.xtext.ui.TypeAwareReferenceProposalCreator.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindIValidationJobScheduler() {
+ return org.eclipse.xtext.common.types.xtext.ui.JdtValidationJobScheduler.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindRefactoringResourceSetProvider() {
+ return org.eclipse.xtext.common.types.ui.refactoring.JvmRefactoringResourceSetProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindIJavaSearchParticipation() {
+ return org.eclipse.xtext.common.types.ui.query.IJavaSearchParticipation.Yes.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment
+ public com.google.inject.Provider provideTemplatesLanguageConfiguration() {
+ return org.eclipse.xtext.ui.codetemplates.ui.AccessibleCodetemplatesActivator.getTemplatesLanguageConfigurationProvider();
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment
+ public com.google.inject.Provider provideLanguageRegistry() {
+ return org.eclipse.xtext.ui.codetemplates.ui.AccessibleCodetemplatesActivator.getLanguageRegistry();
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment
+ @org.eclipse.xtext.service.SingletonBinding(eager=true) public Class bindLanguageRegistrar() {
+ return org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistrar.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment
+ public Class bindXtextTemplatePreferencePage() {
+ return org.eclipse.xtext.ui.codetemplates.ui.preferences.AdvancedTemplatesPreferencePage.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment
+ public Class bindIPartialContentAssistParser() {
+ return csep.example.cake.ui.contentassist.antlr.PartialCakefileContentAssistParser.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment
+ public Class bindIRenameStrategy() {
+ return org.eclipse.xtext.ui.refactoring.impl.DefaultRenameStrategy.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment
+ public Class bindIReferenceUpdater() {
+ return org.eclipse.xtext.ui.refactoring.impl.DefaultReferenceUpdater.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment
+ public void configureIPreferenceStoreInitializer(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.ui.editor.preferences.IPreferenceStoreInitializer.class).annotatedWith(com.google.inject.name.Names.named("RefactoringPreferences")).to(org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferences.Initializer.class);
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment
+ public Class bindIRenameRefactoringProvider() {
+ return org.eclipse.xtext.ui.refactoring.impl.DefaultRenameRefactoringProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment
+ public Class bindIRenameSupport$Factory() {
+ return org.eclipse.xtext.ui.refactoring.ui.DefaultRenameSupport.Factory.class;
+ }
+
+ // contributed by org.eclipse.xtext.ui.generator.compare.CompareFragment
+ public Class bindIViewerCreator() {
+ return org.eclipse.xtext.ui.compare.DefaultViewerCreator.class;
+ }
+
+
+}
diff --git a/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/CakefileExecutableExtensionFactory.java b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/CakefileExecutableExtensionFactory.java
new file mode 100644
index 0000000..04f3621
--- /dev/null
+++ b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/CakefileExecutableExtensionFactory.java
@@ -0,0 +1,29 @@
+/*
+ * generated by Xtext
+ */
+package csep.example.cake.ui;
+
+import org.eclipse.xtext.ui.guice.AbstractGuiceAwareExecutableExtensionFactory;
+import org.osgi.framework.Bundle;
+
+import com.google.inject.Injector;
+
+import csep.example.cake.ui.internal.CakefileActivator;
+
+/**
+ * This class was generated. Customizations should only happen in a newly
+ * introduced subclass.
+ */
+public class CakefileExecutableExtensionFactory extends AbstractGuiceAwareExecutableExtensionFactory {
+
+ @Override
+ protected Bundle getBundle() {
+ return CakefileActivator.getInstance().getBundle();
+ }
+
+ @Override
+ protected Injector getInjector() {
+ return CakefileActivator.getInstance().getInjector(CakefileActivator.CSEP_EXAMPLE_CAKE_CAKEFILE);
+ }
+
+}
diff --git a/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/AbstractCakefileProposalProvider.java b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/AbstractCakefileProposalProvider.java
new file mode 100644
index 0000000..dd5773b
--- /dev/null
+++ b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/AbstractCakefileProposalProvider.java
@@ -0,0 +1,44 @@
+/*
+* generated by Xtext
+*/
+package csep.example.cake.ui.contentassist;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor;
+import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
+
+/**
+ * Represents a generated, default implementation of interface {@link IProposalProvider}.
+ * Methods are dynamically dispatched on the first parameter, i.e., you can override them
+ * with a more concrete subtype.
+ */
+@SuppressWarnings("all")
+public class AbstractCakefileProposalProvider extends csep.ui.contentassist.CoffeeScriptProposalProvider {
+
+ public void completeCakefile_Tasks(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTaskDeclaration_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTaskDeclaration_Description(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTaskDeclaration_Options(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+ public void completeTaskDeclaration_Body(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+ }
+
+ public void complete_Cakefile(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_TaskDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+ public void complete_TASK(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+ // subclasses may override
+ }
+}
diff --git a/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/CakefileParser.java b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/CakefileParser.java
new file mode 100644
index 0000000..bf86eaf
--- /dev/null
+++ b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/CakefileParser.java
@@ -0,0 +1,406 @@
+/*
+* generated by Xtext
+*/
+package csep.example.cake.ui.contentassist.antlr;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.antlr.runtime.RecognitionException;
+import org.eclipse.xtext.AbstractElement;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.AbstractContentAssistParser;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.FollowElement;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+
+import com.google.inject.Inject;
+
+import csep.example.cake.services.CakefileGrammarAccess;
+
+public class CakefileParser extends AbstractContentAssistParser {
+
+ @Inject
+ private CakefileGrammarAccess grammarAccess;
+
+ private Map nameMappings;
+
+ @Override
+ protected csep.example.cake.ui.contentassist.antlr.internal.InternalCakefileParser createParser() {
+ csep.example.cake.ui.contentassist.antlr.internal.InternalCakefileParser result = new csep.example.cake.ui.contentassist.antlr.internal.InternalCakefileParser(null);
+ result.setGrammarAccess(grammarAccess);
+ return result;
+ }
+
+ @Override
+ protected String getRuleName(AbstractElement element) {
+ if (nameMappings == null) {
+ nameMappings = new HashMap() {
+ private static final long serialVersionUID = 1L;
+ {
+ put(grammarAccess.getRootAccess().getAlternatives(), "rule__Root__Alternatives");
+ put(grammarAccess.getLineAccess().getAlternatives(), "rule__Line__Alternatives");
+ put(grammarAccess.getStmtAccess().getAlternatives(), "rule__Stmt__Alternatives");
+ put(grammarAccess.getSuperClassAccess().getAlternatives(), "rule__SuperClass__Alternatives");
+ put(grammarAccess.getClassDeclarationAccess().getAlternatives_2(), "rule__ClassDeclaration__Alternatives_2");
+ put(grammarAccess.getClassDeclarationAccess().getNameAlternatives_2_2_0_0(), "rule__ClassDeclaration__NameAlternatives_2_2_0_0");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getAlternatives_2(), "rule__AssignedClassDeclaration__Alternatives_2");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getNameAlternatives_2_1_0_0(), "rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0");
+ put(grammarAccess.getPostfixAccess().getAlternatives_1(), "rule__Postfix__Alternatives_1");
+ put(grammarAccess.getForSourceAccess().getAlternatives_1(), "rule__ForSource__Alternatives_1");
+ put(grammarAccess.getForSourceAccess().getAlternatives_1_1_2(), "rule__ForSource__Alternatives_1_1_2");
+ put(grammarAccess.getRangeAccess().getAlternatives_0_0_2(), "rule__Range__Alternatives_0_0_2");
+ put(grammarAccess.getAssignmentAccess().getAlternatives(), "rule__Assignment__Alternatives");
+ put(grammarAccess.getAssignmentAccess().getOperatorAlternatives_0_0_0_1_0(), "rule__Assignment__OperatorAlternatives_0_0_0_1_0");
+ put(grammarAccess.getAssignedAccess().getAlternatives(), "rule__Assigned__Alternatives");
+ put(grammarAccess.getAdditiveOpAccess().getOperatorAlternatives_1_0_0_1_0(), "rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0");
+ put(grammarAccess.getUnaryOpAccess().getAlternatives(), "rule__UnaryOp__Alternatives");
+ put(grammarAccess.getUnaryOpAccess().getAlternatives_0_0(), "rule__UnaryOp__Alternatives_0_0");
+ put(grammarAccess.getUnaryOpAccess().getAlternatives_1_0(), "rule__UnaryOp__Alternatives_1_0");
+ put(grammarAccess.getApplicationAccess().getAlternatives(), "rule__Application__Alternatives");
+ put(grammarAccess.getFeatureCallAccess().getAlternatives(), "rule__FeatureCall__Alternatives");
+ put(grammarAccess.getPropertyAccessAccess().getAlternatives(), "rule__PropertyAccess__Alternatives");
+ put(grammarAccess.getNamedPropertyAccessAccess().getAlternatives(), "rule__NamedPropertyAccess__Alternatives");
+ put(grammarAccess.getNamedPropertyAccessAccess().getAccessorAlternatives_0_0_0(), "rule__NamedPropertyAccess__AccessorAlternatives_0_0_0");
+ put(grammarAccess.getIndexAccess().getAlternatives(), "rule__Index__Alternatives");
+ put(grammarAccess.getIndexAccess().getDotsAlternatives_0_0_0(), "rule__Index__DotsAlternatives_0_0_0");
+ put(grammarAccess.getIndexAccess().getDotsAlternatives_1_0_0_1_0(), "rule__Index__DotsAlternatives_1_0_0_1_0");
+ put(grammarAccess.getPrimaryExpressionAccess().getAlternatives(), "rule__PrimaryExpression__Alternatives");
+ put(grammarAccess.getPrimaryExpressionAccess().getAlternatives_13_1_2(), "rule__PrimaryExpression__Alternatives_13_1_2");
+ put(grammarAccess.getPropertyAccess().getAlternatives(), "rule__Property__Alternatives");
+ put(grammarAccess.getPropertyAccess().getAccessorAlternatives_0_0_0_1_0(), "rule__Property__AccessorAlternatives_0_0_0_1_0");
+ put(grammarAccess.getVariableAccess().getAlternatives(), "rule__Variable__Alternatives");
+ put(grammarAccess.getVariableAccess().getAlternatives_1_0(), "rule__Variable__Alternatives_1_0");
+ put(grammarAccess.getAssignableAccess().getAlternatives(), "rule__Assignable__Alternatives");
+ put(grammarAccess.getExplicitArgListAccess().getAlternatives_1(), "rule__ExplicitArgList__Alternatives_1");
+ put(grammarAccess.getArgListAccess().getAlternatives_1(), "rule__ArgList__Alternatives_1");
+ put(grammarAccess.getDictItemsAccess().getAlternatives_1(), "rule__DictItems__Alternatives_1");
+ put(grammarAccess.getExplicitDictItemsAccess().getAlternatives_1(), "rule__ExplicitDictItems__Alternatives_1");
+ put(grammarAccess.getDictItemAccess().getAlternatives_2_1(), "rule__DictItem__Alternatives_2_1");
+ put(grammarAccess.getDictKeyAccess().getAlternatives(), "rule__DictKey__Alternatives");
+ put(grammarAccess.getLambdaAccess().getAlternatives_1(), "rule__Lambda__Alternatives_1");
+ put(grammarAccess.getParamAccess().getAlternatives_0(), "rule__Param__Alternatives_0");
+ put(grammarAccess.getParamAccess().getAlternatives_1(), "rule__Param__Alternatives_1");
+ put(grammarAccess.getLiteralAccess().getAlternatives(), "rule__Literal__Alternatives");
+ put(grammarAccess.getParentheticalAccess().getAlternatives(), "rule__Parenthetical__Alternatives");
+ put(grammarAccess.getTaskDeclarationAccess().getGroup(), "rule__TaskDeclaration__Group__0");
+ put(grammarAccess.getTaskDeclarationAccess().getGroup_6(), "rule__TaskDeclaration__Group_6__0");
+ put(grammarAccess.getRootAccess().getGroup_1(), "rule__Root__Group_1__0");
+ put(grammarAccess.getBodyAccess().getGroup(), "rule__Body__Group__0");
+ put(grammarAccess.getBodyAccess().getGroup_1(), "rule__Body__Group_1__0");
+ put(grammarAccess.getRequireStmtAccess().getGroup(), "rule__RequireStmt__Group__0");
+ put(grammarAccess.getRequireStmtAccess().getGroup_0(), "rule__RequireStmt__Group_0__0");
+ put(grammarAccess.getRequireStmtAccess().getGroup_0_0(), "rule__RequireStmt__Group_0_0__0");
+ put(grammarAccess.getReturnStmtAccess().getGroup(), "rule__ReturnStmt__Group__0");
+ put(grammarAccess.getReturnStmtAccess().getGroup_3(), "rule__ReturnStmt__Group_3__0");
+ put(grammarAccess.getThrowStmtAccess().getGroup(), "rule__ThrowStmt__Group__0");
+ put(grammarAccess.getClassDeclarationAccess().getGroup(), "rule__ClassDeclaration__Group__0");
+ put(grammarAccess.getClassDeclarationAccess().getGroup_2_1(), "rule__ClassDeclaration__Group_2_1__0");
+ put(grammarAccess.getClassDeclarationAccess().getGroup_2_2(), "rule__ClassDeclaration__Group_2_2__0");
+ put(grammarAccess.getClassDeclarationAccess().getGroup_2_2_1(), "rule__ClassDeclaration__Group_2_2_1__0");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getGroup(), "rule__AssignedClassDeclaration__Group__0");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_0(), "rule__AssignedClassDeclaration__Group_2_0__0");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1(), "rule__AssignedClassDeclaration__Group_2_1__0");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1_1(), "rule__AssignedClassDeclaration__Group_2_1_1__0");
+ put(grammarAccess.getPostfixAccess().getGroup(), "rule__Postfix__Group__0");
+ put(grammarAccess.getPostfixAccess().getGroup_1_0(), "rule__Postfix__Group_1_0__0");
+ put(grammarAccess.getPostfixAccess().getGroup_1_1(), "rule__Postfix__Group_1_1__0");
+ put(grammarAccess.getPostfixAccess().getGroup_1_2(), "rule__Postfix__Group_1_2__0");
+ put(grammarAccess.getPostfixAccess().getGroup_1_2_3(), "rule__Postfix__Group_1_2_3__0");
+ put(grammarAccess.getPostfixAccess().getGroup_1_3(), "rule__Postfix__Group_1_3__0");
+ put(grammarAccess.getPostfixAccess().getGroup_1_3_3(), "rule__Postfix__Group_1_3_3__0");
+ put(grammarAccess.getForBodyAccess().getGroup(), "rule__ForBody__Group__0");
+ put(grammarAccess.getForBodyAccess().getGroup_2(), "rule__ForBody__Group_2__0");
+ put(grammarAccess.getForSourceAccess().getGroup(), "rule__ForSource__Group__0");
+ put(grammarAccess.getForSourceAccess().getGroup_1_0(), "rule__ForSource__Group_1_0__0");
+ put(grammarAccess.getForSourceAccess().getGroup_1_0_2(), "rule__ForSource__Group_1_0_2__0");
+ put(grammarAccess.getForSourceAccess().getGroup_1_1(), "rule__ForSource__Group_1_1__0");
+ put(grammarAccess.getForSourceAccess().getGroup_1_1_2_0(), "rule__ForSource__Group_1_1_2_0__0");
+ put(grammarAccess.getForSourceAccess().getGroup_1_1_2_0_2(), "rule__ForSource__Group_1_1_2_0_2__0");
+ put(grammarAccess.getForSourceAccess().getGroup_1_1_2_1(), "rule__ForSource__Group_1_1_2_1__0");
+ put(grammarAccess.getForSourceAccess().getGroup_1_1_2_1_2(), "rule__ForSource__Group_1_1_2_1_2__0");
+ put(grammarAccess.getRangeAccess().getGroup(), "rule__Range__Group__0");
+ put(grammarAccess.getRangeAccess().getGroup_0(), "rule__Range__Group_0__0");
+ put(grammarAccess.getRangeAccess().getGroup_0_0(), "rule__Range__Group_0_0__0");
+ put(grammarAccess.getAssignmentAccess().getGroup_0(), "rule__Assignment__Group_0__0");
+ put(grammarAccess.getAssignmentAccess().getGroup_0_0(), "rule__Assignment__Group_0_0__0");
+ put(grammarAccess.getAssignmentAccess().getGroup_0_0_0(), "rule__Assignment__Group_0_0_0__0");
+ put(grammarAccess.getAssignedAccess().getGroup_1(), "rule__Assigned__Group_1__0");
+ put(grammarAccess.getLogicOpAccess().getGroup(), "rule__LogicOp__Group__0");
+ put(grammarAccess.getLogicOpAccess().getGroup_1(), "rule__LogicOp__Group_1__0");
+ put(grammarAccess.getLogicOpAccess().getGroup_1_0(), "rule__LogicOp__Group_1_0__0");
+ put(grammarAccess.getLogicOpAccess().getGroup_1_0_0(), "rule__LogicOp__Group_1_0_0__0");
+ put(grammarAccess.getCompareOpAccess().getGroup(), "rule__CompareOp__Group__0");
+ put(grammarAccess.getCompareOpAccess().getGroup_1(), "rule__CompareOp__Group_1__0");
+ put(grammarAccess.getCompareOpAccess().getGroup_1_0(), "rule__CompareOp__Group_1_0__0");
+ put(grammarAccess.getCompareOpAccess().getGroup_1_0_0(), "rule__CompareOp__Group_1_0_0__0");
+ put(grammarAccess.getRelationOpAccess().getGroup(), "rule__RelationOp__Group__0");
+ put(grammarAccess.getRelationOpAccess().getGroup_1(), "rule__RelationOp__Group_1__0");
+ put(grammarAccess.getRelationOpAccess().getGroup_1_0(), "rule__RelationOp__Group_1_0__0");
+ put(grammarAccess.getRelationOpAccess().getGroup_1_0_0(), "rule__RelationOp__Group_1_0_0__0");
+ put(grammarAccess.getShiftOpAccess().getGroup(), "rule__ShiftOp__Group__0");
+ put(grammarAccess.getShiftOpAccess().getGroup_1(), "rule__ShiftOp__Group_1__0");
+ put(grammarAccess.getShiftOpAccess().getGroup_1_0(), "rule__ShiftOp__Group_1_0__0");
+ put(grammarAccess.getShiftOpAccess().getGroup_1_0_0(), "rule__ShiftOp__Group_1_0_0__0");
+ put(grammarAccess.getAdditiveOpAccess().getGroup(), "rule__AdditiveOp__Group__0");
+ put(grammarAccess.getAdditiveOpAccess().getGroup_1(), "rule__AdditiveOp__Group_1__0");
+ put(grammarAccess.getAdditiveOpAccess().getGroup_1_0(), "rule__AdditiveOp__Group_1_0__0");
+ put(grammarAccess.getAdditiveOpAccess().getGroup_1_0_0(), "rule__AdditiveOp__Group_1_0_0__0");
+ put(grammarAccess.getMathOpAccess().getGroup(), "rule__MathOp__Group__0");
+ put(grammarAccess.getMathOpAccess().getGroup_1(), "rule__MathOp__Group_1__0");
+ put(grammarAccess.getMathOpAccess().getGroup_1_0(), "rule__MathOp__Group_1_0__0");
+ put(grammarAccess.getMathOpAccess().getGroup_1_0_0(), "rule__MathOp__Group_1_0_0__0");
+ put(grammarAccess.getUnaryOpAccess().getGroup_0(), "rule__UnaryOp__Group_0__0");
+ put(grammarAccess.getUnaryOpAccess().getGroup_1(), "rule__UnaryOp__Group_1__0");
+ put(grammarAccess.getUnaryOpAccess().getGroup_2(), "rule__UnaryOp__Group_2__0");
+ put(grammarAccess.getApplicationAccess().getGroup_0(), "rule__Application__Group_0__0");
+ put(grammarAccess.getApplicationAccess().getGroup_0_1(), "rule__Application__Group_0_1__0");
+ put(grammarAccess.getApplicationAccess().getGroup_0_1_1(), "rule__Application__Group_0_1_1__0");
+ put(grammarAccess.getApplicationAccess().getGroup_1(), "rule__Application__Group_1__0");
+ put(grammarAccess.getFunctionCallAccess().getGroup(), "rule__FunctionCall__Group__0");
+ put(grammarAccess.getThisPropertyAccess().getGroup(), "rule__ThisProperty__Group__0");
+ put(grammarAccess.getNamedPropertyAccessAccess().getGroup_0(), "rule__NamedPropertyAccess__Group_0__0");
+ put(grammarAccess.getNamedPropertyAccessAccess().getGroup_1(), "rule__NamedPropertyAccess__Group_1__0");
+ put(grammarAccess.getIndexedPropertyAccessAccess().getGroup(), "rule__IndexedPropertyAccess__Group__0");
+ put(grammarAccess.getIndexAccess().getGroup_0(), "rule__Index__Group_0__0");
+ put(grammarAccess.getIndexAccess().getGroup_1(), "rule__Index__Group_1__0");
+ put(grammarAccess.getIndexAccess().getGroup_1_0(), "rule__Index__Group_1_0__0");
+ put(grammarAccess.getIndexAccess().getGroup_1_0_0(), "rule__Index__Group_1_0_0__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_8(), "rule__PrimaryExpression__Group_8__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_9(), "rule__PrimaryExpression__Group_9__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_9_1(), "rule__PrimaryExpression__Group_9_1__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_10(), "rule__PrimaryExpression__Group_10__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1(), "rule__PrimaryExpression__Group_10_1__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1_2(), "rule__PrimaryExpression__Group_10_1_2__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_11(), "rule__PrimaryExpression__Group_11__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1(), "rule__PrimaryExpression__Group_11_1__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1_2(), "rule__PrimaryExpression__Group_11_1_2__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_12(), "rule__PrimaryExpression__Group_12__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_12_1(), "rule__PrimaryExpression__Group_12_1__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_13(), "rule__PrimaryExpression__Group_13__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1(), "rule__PrimaryExpression__Group_13_1__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0(), "rule__PrimaryExpression__Group_13_1_2_0__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0_3(), "rule__PrimaryExpression__Group_13_1_2_0_3__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_1(), "rule__PrimaryExpression__Group_13_1_2_1__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_14(), "rule__PrimaryExpression__Group_14__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1(), "rule__PrimaryExpression__Group_14_1__0");
+ put(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1_4(), "rule__PrimaryExpression__Group_14_1_4__0");
+ put(grammarAccess.getBlockAccess().getGroup(), "rule__Block__Group__0");
+ put(grammarAccess.getCaseAccess().getGroup(), "rule__Case__Group__0");
+ put(grammarAccess.getCaseAccess().getGroup_2(), "rule__Case__Group_2__0");
+ put(grammarAccess.getIfExpAccess().getGroup(), "rule__IfExp__Group__0");
+ put(grammarAccess.getIfExpAccess().getGroup_1(), "rule__IfExp__Group_1__0");
+ put(grammarAccess.getIfExpAccess().getGroup_2(), "rule__IfExp__Group_2__0");
+ put(grammarAccess.getCondBlockAccess().getGroup(), "rule__CondBlock__Group__0");
+ put(grammarAccess.getPropertyAccess().getGroup_0(), "rule__Property__Group_0__0");
+ put(grammarAccess.getPropertyAccess().getGroup_0_0(), "rule__Property__Group_0_0__0");
+ put(grammarAccess.getPropertyAccess().getGroup_0_0_0(), "rule__Property__Group_0_0_0__0");
+ put(grammarAccess.getPropertyAccess().getGroup_1(), "rule__Property__Group_1__0");
+ put(grammarAccess.getPropertyAccess().getGroup_1_0(), "rule__Property__Group_1_0__0");
+ put(grammarAccess.getPropertyAccess().getGroup_1_0_0(), "rule__Property__Group_1_0_0__0");
+ put(grammarAccess.getVariableAccess().getGroup_1(), "rule__Variable__Group_1__0");
+ put(grammarAccess.getVariableAccess().getGroup_1_0_1(), "rule__Variable__Group_1_0_1__0");
+ put(grammarAccess.getVariableAccess().getGroup_1_2(), "rule__Variable__Group_1_2__0");
+ put(grammarAccess.getAssignableArrayAccess().getGroup(), "rule__AssignableArray__Group__0");
+ put(grammarAccess.getAssignableArgListAccess().getGroup(), "rule__AssignableArgList__Group__0");
+ put(grammarAccess.getAssignableArgListAccess().getGroup_1(), "rule__AssignableArgList__Group_1__0");
+ put(grammarAccess.getAssignableArgAccess().getGroup(), "rule__AssignableArg__Group__0");
+ put(grammarAccess.getArgAccess().getGroup(), "rule__Arg__Group__0");
+ put(grammarAccess.getArgLineAccess().getGroup(), "rule__ArgLine__Group__0");
+ put(grammarAccess.getArgLineAccess().getGroup_1(), "rule__ArgLine__Group_1__0");
+ put(grammarAccess.getExplicitArgListAccess().getGroup(), "rule__ExplicitArgList__Group__0");
+ put(grammarAccess.getExplicitArgListAccess().getGroup_1_0(), "rule__ExplicitArgList__Group_1_0__0");
+ put(grammarAccess.getExplicitArgListAccess().getGroup_1_1(), "rule__ExplicitArgList__Group_1_1__0");
+ put(grammarAccess.getArgListAccess().getGroup(), "rule__ArgList__Group__0");
+ put(grammarAccess.getArgListAccess().getGroup_1_1(), "rule__ArgList__Group_1_1__0");
+ put(grammarAccess.getArrayAccess().getGroup(), "rule__Array__Group__0");
+ put(grammarAccess.getDictionaryAccess().getGroup(), "rule__Dictionary__Group__0");
+ put(grammarAccess.getDictItemsAccess().getGroup(), "rule__DictItems__Group__0");
+ put(grammarAccess.getDictItemsAccess().getGroup_1_1(), "rule__DictItems__Group_1_1__0");
+ put(grammarAccess.getExplicitDictItemsAccess().getGroup(), "rule__ExplicitDictItems__Group__0");
+ put(grammarAccess.getExplicitDictItemsAccess().getGroup_1_0(), "rule__ExplicitDictItems__Group_1_0__0");
+ put(grammarAccess.getExplicitDictItemsAccess().getGroup_1_1(), "rule__ExplicitDictItems__Group_1_1__0");
+ put(grammarAccess.getDictLineAccess().getGroup(), "rule__DictLine__Group__0");
+ put(grammarAccess.getDictLineAccess().getGroup_1(), "rule__DictLine__Group_1__0");
+ put(grammarAccess.getDictItemAccess().getGroup(), "rule__DictItem__Group__0");
+ put(grammarAccess.getDictItemAccess().getGroup_2(), "rule__DictItem__Group_2__0");
+ put(grammarAccess.getDictItemAccess().getGroup_2_1_1(), "rule__DictItem__Group_2_1_1__0");
+ put(grammarAccess.getLambdaAccess().getGroup(), "rule__Lambda__Group__0");
+ put(grammarAccess.getLambdaAccess().getGroup_0(), "rule__Lambda__Group_0__0");
+ put(grammarAccess.getLambdaAccess().getGroup_0_1(), "rule__Lambda__Group_0_1__0");
+ put(grammarAccess.getLambdaAccess().getGroup_0_1_1(), "rule__Lambda__Group_0_1_1__0");
+ put(grammarAccess.getParamAccess().getGroup(), "rule__Param__Group__0");
+ put(grammarAccess.getParamAccess().getGroup_1_1(), "rule__Param__Group_1_1__0");
+ put(grammarAccess.getNumberLiteralAccess().getGroup(), "rule__NumberLiteral__Group__0");
+ put(grammarAccess.getStringLiteralAccess().getGroup(), "rule__StringLiteral__Group__0");
+ put(grammarAccess.getBoolLiteralAccess().getGroup(), "rule__BoolLiteral__Group__0");
+ put(grammarAccess.getJSLiteralAccess().getGroup(), "rule__JSLiteral__Group__0");
+ put(grammarAccess.getRegexLiteralAccess().getGroup(), "rule__RegexLiteral__Group__0");
+ put(grammarAccess.getParentheticalAccess().getGroup_0(), "rule__Parenthetical__Group_0__0");
+ put(grammarAccess.getParentheticalAccess().getGroup_0_0(), "rule__Parenthetical__Group_0_0__0");
+ put(grammarAccess.getParentheticalAccess().getGroup_0_0_0(), "rule__Parenthetical__Group_0_0_0__0");
+ put(grammarAccess.getParentheticalAccess().getGroup_1(), "rule__Parenthetical__Group_1__0");
+ put(grammarAccess.getCakefileAccess().getTasksAssignment(), "rule__Cakefile__TasksAssignment");
+ put(grammarAccess.getTaskDeclarationAccess().getNameAssignment_2(), "rule__TaskDeclaration__NameAssignment_2");
+ put(grammarAccess.getTaskDeclarationAccess().getDescriptionAssignment_4(), "rule__TaskDeclaration__DescriptionAssignment_4");
+ put(grammarAccess.getTaskDeclarationAccess().getOptionsAssignment_6_1(), "rule__TaskDeclaration__OptionsAssignment_6_1");
+ put(grammarAccess.getTaskDeclarationAccess().getBodyAssignment_8(), "rule__TaskDeclaration__BodyAssignment_8");
+ put(grammarAccess.getBodyAccess().getLinesAssignment_0(), "rule__Body__LinesAssignment_0");
+ put(grammarAccess.getBodyAccess().getLinesAssignment_1_1(), "rule__Body__LinesAssignment_1_1");
+ put(grammarAccess.getStmtAccess().getStatementAssignment_5(), "rule__Stmt__StatementAssignment_5");
+ put(grammarAccess.getCommentAccess().getCommentAssignment(), "rule__Comment__CommentAssignment");
+ put(grammarAccess.getRequireStmtAccess().getImportedNamespaceAssignment_0_0_0(), "rule__RequireStmt__ImportedNamespaceAssignment_0_0_0");
+ put(grammarAccess.getRequireStmtAccess().getUriAssignment_2(), "rule__RequireStmt__UriAssignment_2");
+ put(grammarAccess.getReturnStmtAccess().getExpressionAssignment_2(), "rule__ReturnStmt__ExpressionAssignment_2");
+ put(grammarAccess.getReturnStmtAccess().getConditionAssignment_3_1(), "rule__ReturnStmt__ConditionAssignment_3_1");
+ put(grammarAccess.getThrowStmtAccess().getExpAssignment_1(), "rule__ThrowStmt__ExpAssignment_1");
+ put(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_0(), "rule__ClassDeclaration__BodyAssignment_2_0");
+ put(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_1_1(), "rule__ClassDeclaration__ExtendAssignment_2_1_1");
+ put(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_1_2(), "rule__ClassDeclaration__BodyAssignment_2_1_2");
+ put(grammarAccess.getClassDeclarationAccess().getNameAssignment_2_2_0(), "rule__ClassDeclaration__NameAssignment_2_2_0");
+ put(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_2_1_1(), "rule__ClassDeclaration__ExtendAssignment_2_2_1_1");
+ put(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_2_2(), "rule__ClassDeclaration__BodyAssignment_2_2_2");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_0_1(), "rule__AssignedClassDeclaration__ExtendAssignment_2_0_1");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_0_2(), "rule__AssignedClassDeclaration__BodyAssignment_2_0_2");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getNameAssignment_2_1_0(), "rule__AssignedClassDeclaration__NameAssignment_2_1_0");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_1_1_1(), "rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1");
+ put(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_1_2(), "rule__AssignedClassDeclaration__BodyAssignment_2_1_2");
+ put(grammarAccess.getPostfixAccess().getConditionAssignment_1_0_2(), "rule__Postfix__ConditionAssignment_1_0_2");
+ put(grammarAccess.getPostfixAccess().getBodyAssignment_1_1_2(), "rule__Postfix__BodyAssignment_1_1_2");
+ put(grammarAccess.getPostfixAccess().getBodyAssignment_1_2_2(), "rule__Postfix__BodyAssignment_1_2_2");
+ put(grammarAccess.getPostfixAccess().getWhenAssignment_1_2_3_1(), "rule__Postfix__WhenAssignment_1_2_3_1");
+ put(grammarAccess.getPostfixAccess().getBodyAssignment_1_3_2(), "rule__Postfix__BodyAssignment_1_3_2");
+ put(grammarAccess.getPostfixAccess().getWhenAssignment_1_3_3_1(), "rule__Postfix__WhenAssignment_1_3_3_1");
+ put(grammarAccess.getForBodyAccess().getIndexesAssignment_1(), "rule__ForBody__IndexesAssignment_1");
+ put(grammarAccess.getForBodyAccess().getIndexesAssignment_2_1(), "rule__ForBody__IndexesAssignment_2_1");
+ put(grammarAccess.getForBodyAccess().getSourceAssignment_3(), "rule__ForBody__SourceAssignment_3");
+ put(grammarAccess.getForSourceAccess().getSourceAssignment_1_0_1(), "rule__ForSource__SourceAssignment_1_0_1");
+ put(grammarAccess.getForSourceAccess().getWhenAssignment_1_0_2_1(), "rule__ForSource__WhenAssignment_1_0_2_1");
+ put(grammarAccess.getForSourceAccess().getSourceAssignment_1_1_1(), "rule__ForSource__SourceAssignment_1_1_1");
+ put(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_0_1(), "rule__ForSource__WhenAssignment_1_1_2_0_1");
+ put(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_0_2_1(), "rule__ForSource__ByAssignment_1_1_2_0_2_1");
+ put(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_1_1(), "rule__ForSource__ByAssignment_1_1_2_1_1");
+ put(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_1_2_1(), "rule__ForSource__WhenAssignment_1_1_2_1_2_1");
+ put(grammarAccess.getRangeAccess().getStartAssignment_0_0_1(), "rule__Range__StartAssignment_0_0_1");
+ put(grammarAccess.getRangeAccess().getEndAssignment_1(), "rule__Range__EndAssignment_1");
+ put(grammarAccess.getAssignmentAccess().getLeftAssignment_0_0_0_0(), "rule__Assignment__LeftAssignment_0_0_0_0");
+ put(grammarAccess.getAssignmentAccess().getOperatorAssignment_0_0_0_1(), "rule__Assignment__OperatorAssignment_0_0_0_1");
+ put(grammarAccess.getAssignmentAccess().getRightAssignment_0_1(), "rule__Assignment__RightAssignment_0_1");
+ put(grammarAccess.getLogicOpAccess().getOperatorAssignment_1_0_0_1(), "rule__LogicOp__OperatorAssignment_1_0_0_1");
+ put(grammarAccess.getLogicOpAccess().getRightAssignment_1_1(), "rule__LogicOp__RightAssignment_1_1");
+ put(grammarAccess.getCompareOpAccess().getOperatorAssignment_1_0_0_1(), "rule__CompareOp__OperatorAssignment_1_0_0_1");
+ put(grammarAccess.getCompareOpAccess().getRightAssignment_1_1(), "rule__CompareOp__RightAssignment_1_1");
+ put(grammarAccess.getRelationOpAccess().getOperatorAssignment_1_0_0_1(), "rule__RelationOp__OperatorAssignment_1_0_0_1");
+ put(grammarAccess.getRelationOpAccess().getRightAssignment_1_1(), "rule__RelationOp__RightAssignment_1_1");
+ put(grammarAccess.getShiftOpAccess().getOperatorAssignment_1_0_0_1(), "rule__ShiftOp__OperatorAssignment_1_0_0_1");
+ put(grammarAccess.getShiftOpAccess().getRightAssignment_1_1(), "rule__ShiftOp__RightAssignment_1_1");
+ put(grammarAccess.getAdditiveOpAccess().getOperatorAssignment_1_0_0_1(), "rule__AdditiveOp__OperatorAssignment_1_0_0_1");
+ put(grammarAccess.getAdditiveOpAccess().getRightAssignment_1_1(), "rule__AdditiveOp__RightAssignment_1_1");
+ put(grammarAccess.getMathOpAccess().getOperatorAssignment_1_0_0_1(), "rule__MathOp__OperatorAssignment_1_0_0_1");
+ put(grammarAccess.getMathOpAccess().getRightAssignment_1_1(), "rule__MathOp__RightAssignment_1_1");
+ put(grammarAccess.getApplicationAccess().getArgsAssignment_0_1_1_1(), "rule__Application__ArgsAssignment_0_1_1_1");
+ put(grammarAccess.getApplicationAccess().getValueAssignment_1_0(), "rule__Application__ValueAssignment_1_0");
+ put(grammarAccess.getApplicationAccess().getFeaturesAssignment_1_1(), "rule__Application__FeaturesAssignment_1_1");
+ put(grammarAccess.getFunctionCallAccess().getArgsAssignment_3(), "rule__FunctionCall__ArgsAssignment_3");
+ put(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_0_0(), "rule__NamedPropertyAccess__AccessorAssignment_0_0");
+ put(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_0_1(), "rule__NamedPropertyAccess__NameAssignment_0_1");
+ put(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_1_0(), "rule__NamedPropertyAccess__AccessorAssignment_1_0");
+ put(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_1_1(), "rule__NamedPropertyAccess__NameAssignment_1_1");
+ put(grammarAccess.getIndexedPropertyAccessAccess().getIndexAssignment_1(), "rule__IndexedPropertyAccess__IndexAssignment_1");
+ put(grammarAccess.getIndexAccess().getDotsAssignment_0_0(), "rule__Index__DotsAssignment_0_0");
+ put(grammarAccess.getIndexAccess().getEndAssignment_0_1(), "rule__Index__EndAssignment_0_1");
+ put(grammarAccess.getIndexAccess().getStartAssignment_1_0_0_0(), "rule__Index__StartAssignment_1_0_0_0");
+ put(grammarAccess.getIndexAccess().getDotsAssignment_1_0_0_1(), "rule__Index__DotsAssignment_1_0_0_1");
+ put(grammarAccess.getIndexAccess().getEndAssignment_1_1(), "rule__Index__EndAssignment_1_1");
+ put(grammarAccess.getIndexAccess().getExpAssignment_2(), "rule__Index__ExpAssignment_2");
+ put(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_9_1_1(), "rule__PrimaryExpression__LoopAssignment_9_1_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_9_1_2(), "rule__PrimaryExpression__BodyAssignment_9_1_2");
+ put(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_10_1_1(), "rule__PrimaryExpression__LoopAssignment_10_1_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_10_1_2_1(), "rule__PrimaryExpression__WhenAssignment_10_1_2_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_10_1_3(), "rule__PrimaryExpression__BodyAssignment_10_1_3");
+ put(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_11_1_1(), "rule__PrimaryExpression__LoopAssignment_11_1_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_11_1_2_1(), "rule__PrimaryExpression__WhenAssignment_11_1_2_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_11_1_3(), "rule__PrimaryExpression__BodyAssignment_11_1_3");
+ put(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_12_1_1(), "rule__PrimaryExpression__BodyAssignment_12_1_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_13_1_1(), "rule__PrimaryExpression__BodyAssignment_13_1_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getExceptionAssignment_13_1_2_0_1(), "rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getCatchBlockAssignment_13_1_2_0_2(), "rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2");
+ put(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_0_3_1(), "rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_1_1(), "rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getExpAssignment_14_1_1(), "rule__PrimaryExpression__ExpAssignment_14_1_1");
+ put(grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_14_1_3(), "rule__PrimaryExpression__CasesAssignment_14_1_3");
+ put(grammarAccess.getPrimaryExpressionAccess().getElseBlockAssignment_14_1_4_1(), "rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1");
+ put(grammarAccess.getCaseAccess().getWhensAssignment_1(), "rule__Case__WhensAssignment_1");
+ put(grammarAccess.getCaseAccess().getWhensAssignment_2_1(), "rule__Case__WhensAssignment_2_1");
+ put(grammarAccess.getCaseAccess().getThenAssignment_3(), "rule__Case__ThenAssignment_3");
+ put(grammarAccess.getIfExpAccess().getBlocksAssignment_0(), "rule__IfExp__BlocksAssignment_0");
+ put(grammarAccess.getIfExpAccess().getBlocksAssignment_1_1(), "rule__IfExp__BlocksAssignment_1_1");
+ put(grammarAccess.getIfExpAccess().getDefaultBlockAssignment_2_1(), "rule__IfExp__DefaultBlockAssignment_2_1");
+ put(grammarAccess.getCondBlockAccess().getOperatorAssignment_0(), "rule__CondBlock__OperatorAssignment_0");
+ put(grammarAccess.getCondBlockAccess().getConditionAssignment_1(), "rule__CondBlock__ConditionAssignment_1");
+ put(grammarAccess.getCondBlockAccess().getActionAssignment_2(), "rule__CondBlock__ActionAssignment_2");
+ put(grammarAccess.getIdRefAccess().getValAssignment(), "rule__IdRef__ValAssignment");
+ put(grammarAccess.getIdAccess().getNameAssignment(), "rule__Id__NameAssignment");
+ put(grammarAccess.getPropertyAccess().getAccessorAssignment_0_0_0_1(), "rule__Property__AccessorAssignment_0_0_0_1");
+ put(grammarAccess.getPropertyAccess().getPropAssignment_0_1(), "rule__Property__PropAssignment_0_1");
+ put(grammarAccess.getPropertyAccess().getIndexAssignment_1_1(), "rule__Property__IndexAssignment_1_1");
+ put(grammarAccess.getVariableAccess().getPropsAssignment_1_2_1(), "rule__Variable__PropsAssignment_1_2_1");
+ put(grammarAccess.getAssignableArgListAccess().getArgsAssignment_0(), "rule__AssignableArgList__ArgsAssignment_0");
+ put(grammarAccess.getAssignableArgListAccess().getArgsAssignment_1_1(), "rule__AssignableArgList__ArgsAssignment_1_1");
+ put(grammarAccess.getAssignableArgAccess().getArgAssignment_0(), "rule__AssignableArg__ArgAssignment_0");
+ put(grammarAccess.getAssignableArgAccess().getSplatAssignment_1(), "rule__AssignableArg__SplatAssignment_1");
+ put(grammarAccess.getArgAccess().getExpAssignment_0(), "rule__Arg__ExpAssignment_0");
+ put(grammarAccess.getArgAccess().getSplatAssignment_1(), "rule__Arg__SplatAssignment_1");
+ put(grammarAccess.getArgLineAccess().getHeadAssignment_0(), "rule__ArgLine__HeadAssignment_0");
+ put(grammarAccess.getArgLineAccess().getTailAssignment_1_1(), "rule__ArgLine__TailAssignment_1_1");
+ put(grammarAccess.getExplicitArgListAccess().getLinesAssignment_0(), "rule__ExplicitArgList__LinesAssignment_0");
+ put(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_0_1(), "rule__ExplicitArgList__LinesAssignment_1_0_1");
+ put(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_1_1(), "rule__ExplicitArgList__LinesAssignment_1_1_1");
+ put(grammarAccess.getArgListAccess().getDummyAssignment_1_0(), "rule__ArgList__DummyAssignment_1_0");
+ put(grammarAccess.getArgListAccess().getDummyAssignment_1_1_1(), "rule__ArgList__DummyAssignment_1_1_1");
+ put(grammarAccess.getDictItemsAccess().getDummyAssignment_1_0(), "rule__DictItems__DummyAssignment_1_0");
+ put(grammarAccess.getDictItemsAccess().getDummyAssignment_1_1_1(), "rule__DictItems__DummyAssignment_1_1_1");
+ put(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_0(), "rule__ExplicitDictItems__LinesAssignment_0");
+ put(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_0_1(), "rule__ExplicitDictItems__LinesAssignment_1_0_1");
+ put(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_1_1(), "rule__ExplicitDictItems__LinesAssignment_1_1_1");
+ put(grammarAccess.getDictLineAccess().getHeadAssignment_0(), "rule__DictLine__HeadAssignment_0");
+ put(grammarAccess.getDictLineAccess().getTailAssignment_1_1(), "rule__DictLine__TailAssignment_1_1");
+ put(grammarAccess.getDictItemAccess().getKeyAssignment_1(), "rule__DictItem__KeyAssignment_1");
+ put(grammarAccess.getDictItemAccess().getValueAssignment_2_1_0(), "rule__DictItem__ValueAssignment_2_1_0");
+ put(grammarAccess.getDictItemAccess().getValueAssignment_2_1_1_1(), "rule__DictItem__ValueAssignment_2_1_1_1");
+ put(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_0(), "rule__Lambda__ParamsAssignment_0_1_0");
+ put(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_1_1(), "rule__Lambda__ParamsAssignment_0_1_1_1");
+ put(grammarAccess.getLambdaAccess().getBodyAssignment_2(), "rule__Lambda__BodyAssignment_2");
+ put(grammarAccess.getParamAccess().getSplatAssignment_1_0(), "rule__Param__SplatAssignment_1_0");
+ put(grammarAccess.getParamAccess().getDefaultValueAssignment_1_1_1(), "rule__Param__DefaultValueAssignment_1_1_1");
+ put(grammarAccess.getParentheticalAccess().getContentAssignment_0_1(), "rule__Parenthetical__ContentAssignment_0_1");
+ put(grammarAccess.getParentheticalAccess().getContentAssignment_1_1(), "rule__Parenthetical__ContentAssignment_1_1");
+ }
+ };
+ }
+ return nameMappings.get(element);
+ }
+
+ @Override
+ protected Collection getFollowElements(AbstractInternalContentAssistParser parser) {
+ try {
+ csep.example.cake.ui.contentassist.antlr.internal.InternalCakefileParser typedParser = (csep.example.cake.ui.contentassist.antlr.internal.InternalCakefileParser) parser;
+ typedParser.entryRuleCakefile();
+ return typedParser.getFollowElements();
+ } catch(RecognitionException ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ @Override
+ protected String[] getInitialHiddenTokens() {
+ return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" };
+ }
+
+ public CakefileGrammarAccess getGrammarAccess() {
+ return this.grammarAccess;
+ }
+
+ public void setGrammarAccess(CakefileGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+}
diff --git a/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/PartialCakefileContentAssistParser.java b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/PartialCakefileContentAssistParser.java
new file mode 100644
index 0000000..d691950
--- /dev/null
+++ b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/PartialCakefileContentAssistParser.java
@@ -0,0 +1,37 @@
+/*
+ * generated by Xtext
+ */
+package csep.example.cake.ui.contentassist.antlr;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import org.eclipse.xtext.AbstractRule;
+import org.eclipse.xtext.ui.codetemplates.ui.partialEditing.IPartialContentAssistParser;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.FollowElement;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.util.PolymorphicDispatcher;
+
+/**
+ * @author Sebastian Zarnekow - Initial contribution and API
+ */
+public class PartialCakefileContentAssistParser extends CakefileParser implements IPartialContentAssistParser {
+
+ private AbstractRule rule;
+
+ public void initializeFor(AbstractRule rule) {
+ this.rule = rule;
+ }
+
+ @Override
+ protected Collection getFollowElements(AbstractInternalContentAssistParser parser) {
+ if (rule == null || rule.eIsProxy())
+ return Collections.emptyList();
+ String methodName = "entryRule" + rule.getName();
+ PolymorphicDispatcher> dispatcher =
+ new PolymorphicDispatcher>(methodName, 0, 0, Collections.singletonList(parser));
+ dispatcher.invoke();
+ return parser.getFollowElements();
+ }
+
+}
diff --git a/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g
new file mode 100644
index 0000000..17db83c
--- /dev/null
+++ b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g
@@ -0,0 +1,16937 @@
+/*
+* generated by Xtext
+*/
+grammar InternalCakefile;
+
+options {
+ superClass=AbstractInternalContentAssistParser;
+ backtrack=true;
+
+}
+
+@lexer::header {
+package csep.example.cake.ui.contentassist.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer;
+}
+
+@parser::header {
+package csep.example.cake.ui.contentassist.antlr.internal;
+
+import java.io.InputStream;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA;
+import csep.example.cake.services.CakefileGrammarAccess;
+
+}
+
+@parser::members {
+
+ private CakefileGrammarAccess grammarAccess;
+
+ public void setGrammarAccess(CakefileGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+
+ @Override
+ protected Grammar getGrammar() {
+ return grammarAccess.getGrammar();
+ }
+
+ @Override
+ protected String getValueForTokenName(String tokenName) {
+ return tokenName;
+ }
+
+}
+
+
+
+
+// Entry rule entryRuleCakefile
+entryRuleCakefile
+:
+{ before(grammarAccess.getCakefileRule()); }
+ ruleCakefile
+{ after(grammarAccess.getCakefileRule()); }
+ EOF
+;
+
+// Rule Cakefile
+ruleCakefile
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getCakefileAccess().getTasksAssignment()); }
+(rule__Cakefile__TasksAssignment)*
+{ after(grammarAccess.getCakefileAccess().getTasksAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTaskDeclaration
+entryRuleTaskDeclaration
+:
+{ before(grammarAccess.getTaskDeclarationRule()); }
+ ruleTaskDeclaration
+{ after(grammarAccess.getTaskDeclarationRule()); }
+ EOF
+;
+
+// Rule TaskDeclaration
+ruleTaskDeclaration
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getGroup()); }
+(rule__TaskDeclaration__Group__0)
+{ after(grammarAccess.getTaskDeclarationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+// Entry rule entryRuleBody
+entryRuleBody
+:
+{ before(grammarAccess.getBodyRule()); }
+ ruleBody
+{ after(grammarAccess.getBodyRule()); }
+ EOF
+;
+
+// Rule Body
+ruleBody
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getBodyAccess().getGroup()); }
+(rule__Body__Group__0)
+{ after(grammarAccess.getBodyAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLine
+entryRuleLine
+:
+{ before(grammarAccess.getLineRule()); }
+ ruleLine
+{ after(grammarAccess.getLineRule()); }
+ EOF
+;
+
+// Rule Line
+ruleLine
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLineAccess().getAlternatives()); }
+(rule__Line__Alternatives)
+{ after(grammarAccess.getLineAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStmt
+entryRuleStmt
+:
+{ before(grammarAccess.getStmtRule()); }
+ ruleStmt
+{ after(grammarAccess.getStmtRule()); }
+ EOF
+;
+
+// Rule Stmt
+ruleStmt
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getStmtAccess().getAlternatives()); }
+(rule__Stmt__Alternatives)
+{ after(grammarAccess.getStmtAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleComment
+entryRuleComment
+:
+{ before(grammarAccess.getCommentRule()); }
+ ruleComment
+{ after(grammarAccess.getCommentRule()); }
+ EOF
+;
+
+// Rule Comment
+ruleComment
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getCommentAccess().getCommentAssignment()); }
+(rule__Comment__CommentAssignment)
+{ after(grammarAccess.getCommentAccess().getCommentAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleRequireStmt
+entryRuleRequireStmt
+:
+{ before(grammarAccess.getRequireStmtRule()); }
+ ruleRequireStmt
+{ after(grammarAccess.getRequireStmtRule()); }
+ EOF
+;
+
+// Rule RequireStmt
+ruleRequireStmt
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getRequireStmtAccess().getGroup()); }
+(rule__RequireStmt__Group__0)
+{ after(grammarAccess.getRequireStmtAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleReturnStmt
+entryRuleReturnStmt
+:
+{ before(grammarAccess.getReturnStmtRule()); }
+ ruleReturnStmt
+{ after(grammarAccess.getReturnStmtRule()); }
+ EOF
+;
+
+// Rule ReturnStmt
+ruleReturnStmt
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getReturnStmtAccess().getGroup()); }
+(rule__ReturnStmt__Group__0)
+{ after(grammarAccess.getReturnStmtAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleThrowStmt
+entryRuleThrowStmt
+:
+{ before(grammarAccess.getThrowStmtRule()); }
+ ruleThrowStmt
+{ after(grammarAccess.getThrowStmtRule()); }
+ EOF
+;
+
+// Rule ThrowStmt
+ruleThrowStmt
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getThrowStmtAccess().getGroup()); }
+(rule__ThrowStmt__Group__0)
+{ after(grammarAccess.getThrowStmtAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSuperClass
+entryRuleSuperClass
+:
+{ before(grammarAccess.getSuperClassRule()); }
+ ruleSuperClass
+{ after(grammarAccess.getSuperClassRule()); }
+ EOF
+;
+
+// Rule SuperClass
+ruleSuperClass
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getSuperClassAccess().getAlternatives()); }
+(rule__SuperClass__Alternatives)
+{ after(grammarAccess.getSuperClassAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassDeclaration
+entryRuleClassDeclaration
+:
+{ before(grammarAccess.getClassDeclarationRule()); }
+ ruleClassDeclaration
+{ after(grammarAccess.getClassDeclarationRule()); }
+ EOF
+;
+
+// Rule ClassDeclaration
+ruleClassDeclaration
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getClassDeclarationAccess().getGroup()); }
+(rule__ClassDeclaration__Group__0)
+{ after(grammarAccess.getClassDeclarationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAssignedClassDeclaration
+entryRuleAssignedClassDeclaration
+:
+{ before(grammarAccess.getAssignedClassDeclarationRule()); }
+ ruleAssignedClassDeclaration
+{ after(grammarAccess.getAssignedClassDeclarationRule()); }
+ EOF
+;
+
+// Rule AssignedClassDeclaration
+ruleAssignedClassDeclaration
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getGroup()); }
+(rule__AssignedClassDeclaration__Group__0)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleExpression
+entryRuleExpression
+:
+{ before(grammarAccess.getExpressionRule()); }
+ ruleExpression
+{ after(grammarAccess.getExpressionRule()); }
+ EOF
+;
+
+// Rule Expression
+ruleExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getExpressionAccess().getPostfixParserRuleCall()); }
+ rulePostfix
+{ after(grammarAccess.getExpressionAccess().getPostfixParserRuleCall()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePostfix
+entryRulePostfix
+:
+{ before(grammarAccess.getPostfixRule()); }
+ rulePostfix
+{ after(grammarAccess.getPostfixRule()); }
+ EOF
+;
+
+// Rule Postfix
+rulePostfix
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPostfixAccess().getGroup()); }
+(rule__Postfix__Group__0)
+{ after(grammarAccess.getPostfixAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleForBody
+entryRuleForBody
+:
+{ before(grammarAccess.getForBodyRule()); }
+ ruleForBody
+{ after(grammarAccess.getForBodyRule()); }
+ EOF
+;
+
+// Rule ForBody
+ruleForBody
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getForBodyAccess().getGroup()); }
+(rule__ForBody__Group__0)
+{ after(grammarAccess.getForBodyAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleForValue
+entryRuleForValue
+:
+{ before(grammarAccess.getForValueRule()); }
+ ruleForValue
+{ after(grammarAccess.getForValueRule()); }
+ EOF
+;
+
+// Rule ForValue
+ruleForValue
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getForValueAccess().getIdParserRuleCall()); }
+ ruleId
+{ after(grammarAccess.getForValueAccess().getIdParserRuleCall()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleForSource
+entryRuleForSource
+:
+{ before(grammarAccess.getForSourceRule()); }
+ ruleForSource
+{ after(grammarAccess.getForSourceRule()); }
+ EOF
+;
+
+// Rule ForSource
+ruleForSource
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getForSourceAccess().getGroup()); }
+(rule__ForSource__Group__0)
+{ after(grammarAccess.getForSourceAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleRange
+entryRuleRange
+:
+{ before(grammarAccess.getRangeRule()); }
+ ruleRange
+{ after(grammarAccess.getRangeRule()); }
+ EOF
+;
+
+// Rule Range
+ruleRange
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getRangeAccess().getGroup()); }
+(rule__Range__Group__0)
+{ after(grammarAccess.getRangeAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAssignment
+entryRuleAssignment
+:
+{ before(grammarAccess.getAssignmentRule()); }
+ ruleAssignment
+{ after(grammarAccess.getAssignmentRule()); }
+ EOF
+;
+
+// Rule Assignment
+ruleAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAssignmentAccess().getAlternatives()); }
+(rule__Assignment__Alternatives)
+{ after(grammarAccess.getAssignmentAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAssigned
+entryRuleAssigned
+:
+{ before(grammarAccess.getAssignedRule()); }
+ ruleAssigned
+{ after(grammarAccess.getAssignedRule()); }
+ EOF
+;
+
+// Rule Assigned
+ruleAssigned
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAssignedAccess().getAlternatives()); }
+(rule__Assigned__Alternatives)
+{ after(grammarAccess.getAssignedAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLogicOp
+entryRuleLogicOp
+:
+{ before(grammarAccess.getLogicOpRule()); }
+ ruleLogicOp
+{ after(grammarAccess.getLogicOpRule()); }
+ EOF
+;
+
+// Rule LogicOp
+ruleLogicOp
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLogicOpAccess().getGroup()); }
+(rule__LogicOp__Group__0)
+{ after(grammarAccess.getLogicOpAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleCompareOp
+entryRuleCompareOp
+:
+{ before(grammarAccess.getCompareOpRule()); }
+ ruleCompareOp
+{ after(grammarAccess.getCompareOpRule()); }
+ EOF
+;
+
+// Rule CompareOp
+ruleCompareOp
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getCompareOpAccess().getGroup()); }
+(rule__CompareOp__Group__0)
+{ after(grammarAccess.getCompareOpAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleRelationOp
+entryRuleRelationOp
+:
+{ before(grammarAccess.getRelationOpRule()); }
+ ruleRelationOp
+{ after(grammarAccess.getRelationOpRule()); }
+ EOF
+;
+
+// Rule RelationOp
+ruleRelationOp
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getRelationOpAccess().getGroup()); }
+(rule__RelationOp__Group__0)
+{ after(grammarAccess.getRelationOpAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleShiftOp
+entryRuleShiftOp
+:
+{ before(grammarAccess.getShiftOpRule()); }
+ ruleShiftOp
+{ after(grammarAccess.getShiftOpRule()); }
+ EOF
+;
+
+// Rule ShiftOp
+ruleShiftOp
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getShiftOpAccess().getGroup()); }
+(rule__ShiftOp__Group__0)
+{ after(grammarAccess.getShiftOpAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAdditiveOp
+entryRuleAdditiveOp
+:
+{ before(grammarAccess.getAdditiveOpRule()); }
+ ruleAdditiveOp
+{ after(grammarAccess.getAdditiveOpRule()); }
+ EOF
+;
+
+// Rule AdditiveOp
+ruleAdditiveOp
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAdditiveOpAccess().getGroup()); }
+(rule__AdditiveOp__Group__0)
+{ after(grammarAccess.getAdditiveOpAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleMathOp
+entryRuleMathOp
+:
+{ before(grammarAccess.getMathOpRule()); }
+ ruleMathOp
+{ after(grammarAccess.getMathOpRule()); }
+ EOF
+;
+
+// Rule MathOp
+ruleMathOp
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getMathOpAccess().getGroup()); }
+(rule__MathOp__Group__0)
+{ after(grammarAccess.getMathOpAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleUnaryOp
+entryRuleUnaryOp
+:
+{ before(grammarAccess.getUnaryOpRule()); }
+ ruleUnaryOp
+{ after(grammarAccess.getUnaryOpRule()); }
+ EOF
+;
+
+// Rule UnaryOp
+ruleUnaryOp
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getUnaryOpAccess().getAlternatives()); }
+(rule__UnaryOp__Alternatives)
+{ after(grammarAccess.getUnaryOpAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleApplication
+entryRuleApplication
+:
+{ before(grammarAccess.getApplicationRule()); }
+ ruleApplication
+{ after(grammarAccess.getApplicationRule()); }
+ EOF
+;
+
+// Rule Application
+ruleApplication
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getApplicationAccess().getAlternatives()); }
+(rule__Application__Alternatives)
+{ after(grammarAccess.getApplicationAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleFeatureCall
+entryRuleFeatureCall
+:
+{ before(grammarAccess.getFeatureCallRule()); }
+ ruleFeatureCall
+{ after(grammarAccess.getFeatureCallRule()); }
+ EOF
+;
+
+// Rule FeatureCall
+ruleFeatureCall
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getFeatureCallAccess().getAlternatives()); }
+(rule__FeatureCall__Alternatives)
+{ after(grammarAccess.getFeatureCallAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleFunctionCall
+entryRuleFunctionCall
+:
+{ before(grammarAccess.getFunctionCallRule()); }
+ ruleFunctionCall
+{ after(grammarAccess.getFunctionCallRule()); }
+ EOF
+;
+
+// Rule FunctionCall
+ruleFunctionCall
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getFunctionCallAccess().getGroup()); }
+(rule__FunctionCall__Group__0)
+{ after(grammarAccess.getFunctionCallAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyAccess
+entryRulePropertyAccess
+:
+{ before(grammarAccess.getPropertyAccessRule()); }
+ rulePropertyAccess
+{ after(grammarAccess.getPropertyAccessRule()); }
+ EOF
+;
+
+// Rule PropertyAccess
+rulePropertyAccess
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyAccessAccess().getAlternatives()); }
+(rule__PropertyAccess__Alternatives)
+{ after(grammarAccess.getPropertyAccessAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleThisProperty
+entryRuleThisProperty
+:
+{ before(grammarAccess.getThisPropertyRule()); }
+ ruleThisProperty
+{ after(grammarAccess.getThisPropertyRule()); }
+ EOF
+;
+
+// Rule ThisProperty
+ruleThisProperty
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getThisPropertyAccess().getGroup()); }
+(rule__ThisProperty__Group__0)
+{ after(grammarAccess.getThisPropertyAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNamedPropertyAccess
+entryRuleNamedPropertyAccess
+:
+{ before(grammarAccess.getNamedPropertyAccessRule()); }
+ ruleNamedPropertyAccess
+{ after(grammarAccess.getNamedPropertyAccessRule()); }
+ EOF
+;
+
+// Rule NamedPropertyAccess
+ruleNamedPropertyAccess
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getAlternatives()); }
+(rule__NamedPropertyAccess__Alternatives)
+{ after(grammarAccess.getNamedPropertyAccessAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleIndexedPropertyAccess
+entryRuleIndexedPropertyAccess
+:
+{ before(grammarAccess.getIndexedPropertyAccessRule()); }
+ ruleIndexedPropertyAccess
+{ after(grammarAccess.getIndexedPropertyAccessRule()); }
+ EOF
+;
+
+// Rule IndexedPropertyAccess
+ruleIndexedPropertyAccess
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getIndexedPropertyAccessAccess().getGroup()); }
+(rule__IndexedPropertyAccess__Group__0)
+{ after(grammarAccess.getIndexedPropertyAccessAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleIndex
+entryRuleIndex
+:
+{ before(grammarAccess.getIndexRule()); }
+ ruleIndex
+{ after(grammarAccess.getIndexRule()); }
+ EOF
+;
+
+// Rule Index
+ruleIndex
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getIndexAccess().getAlternatives()); }
+(rule__Index__Alternatives)
+{ after(grammarAccess.getIndexAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePrimaryExpression
+entryRulePrimaryExpression
+:
+{ before(grammarAccess.getPrimaryExpressionRule()); }
+ rulePrimaryExpression
+{ after(grammarAccess.getPrimaryExpressionRule()); }
+ EOF
+;
+
+// Rule PrimaryExpression
+rulePrimaryExpression
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); }
+(rule__PrimaryExpression__Alternatives)
+{ after(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBlock
+entryRuleBlock
+:
+{ before(grammarAccess.getBlockRule()); }
+ ruleBlock
+{ after(grammarAccess.getBlockRule()); }
+ EOF
+;
+
+// Rule Block
+ruleBlock
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getBlockAccess().getGroup()); }
+(rule__Block__Group__0)
+{ after(grammarAccess.getBlockAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleCase
+entryRuleCase
+:
+{ before(grammarAccess.getCaseRule()); }
+ ruleCase
+{ after(grammarAccess.getCaseRule()); }
+ EOF
+;
+
+// Rule Case
+ruleCase
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getCaseAccess().getGroup()); }
+(rule__Case__Group__0)
+{ after(grammarAccess.getCaseAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleIfExp
+entryRuleIfExp
+:
+{ before(grammarAccess.getIfExpRule()); }
+ ruleIfExp
+{ after(grammarAccess.getIfExpRule()); }
+ EOF
+;
+
+// Rule IfExp
+ruleIfExp
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getIfExpAccess().getGroup()); }
+(rule__IfExp__Group__0)
+{ after(grammarAccess.getIfExpAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleCondBlock
+entryRuleCondBlock
+:
+{ before(grammarAccess.getCondBlockRule()); }
+ ruleCondBlock
+{ after(grammarAccess.getCondBlockRule()); }
+ EOF
+;
+
+// Rule CondBlock
+ruleCondBlock
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getCondBlockAccess().getGroup()); }
+(rule__CondBlock__Group__0)
+{ after(grammarAccess.getCondBlockAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleIdRef
+entryRuleIdRef
+:
+{ before(grammarAccess.getIdRefRule()); }
+ ruleIdRef
+{ after(grammarAccess.getIdRefRule()); }
+ EOF
+;
+
+// Rule IdRef
+ruleIdRef
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getIdRefAccess().getValAssignment()); }
+(rule__IdRef__ValAssignment)
+{ after(grammarAccess.getIdRefAccess().getValAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleId
+entryRuleId
+:
+{ before(grammarAccess.getIdRule()); }
+ ruleId
+{ after(grammarAccess.getIdRule()); }
+ EOF
+;
+
+// Rule Id
+ruleId
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getIdAccess().getNameAssignment()); }
+(rule__Id__NameAssignment)
+{ after(grammarAccess.getIdAccess().getNameAssignment()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleProperty
+entryRuleProperty
+:
+{ before(grammarAccess.getPropertyRule()); }
+ ruleProperty
+{ after(grammarAccess.getPropertyRule()); }
+ EOF
+;
+
+// Rule Property
+ruleProperty
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getPropertyAccess().getAlternatives()); }
+(rule__Property__Alternatives)
+{ after(grammarAccess.getPropertyAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleVariable
+entryRuleVariable
+:
+{ before(grammarAccess.getVariableRule()); }
+ ruleVariable
+{ after(grammarAccess.getVariableRule()); }
+ EOF
+;
+
+// Rule Variable
+ruleVariable
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getVariableAccess().getAlternatives()); }
+(rule__Variable__Alternatives)
+{ after(grammarAccess.getVariableAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAssignableArray
+entryRuleAssignableArray
+:
+{ before(grammarAccess.getAssignableArrayRule()); }
+ ruleAssignableArray
+{ after(grammarAccess.getAssignableArrayRule()); }
+ EOF
+;
+
+// Rule AssignableArray
+ruleAssignableArray
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAssignableArrayAccess().getGroup()); }
+(rule__AssignableArray__Group__0)
+{ after(grammarAccess.getAssignableArrayAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAssignableArgList
+entryRuleAssignableArgList
+:
+{ before(grammarAccess.getAssignableArgListRule()); }
+ ruleAssignableArgList
+{ after(grammarAccess.getAssignableArgListRule()); }
+ EOF
+;
+
+// Rule AssignableArgList
+ruleAssignableArgList
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAssignableArgListAccess().getGroup()); }
+(rule__AssignableArgList__Group__0)
+{ after(grammarAccess.getAssignableArgListAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAssignableArg
+entryRuleAssignableArg
+:
+{ before(grammarAccess.getAssignableArgRule()); }
+ ruleAssignableArg
+{ after(grammarAccess.getAssignableArgRule()); }
+ EOF
+;
+
+// Rule AssignableArg
+ruleAssignableArg
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAssignableArgAccess().getGroup()); }
+(rule__AssignableArg__Group__0)
+{ after(grammarAccess.getAssignableArgAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAssignable
+entryRuleAssignable
+:
+{ before(grammarAccess.getAssignableRule()); }
+ ruleAssignable
+{ after(grammarAccess.getAssignableRule()); }
+ EOF
+;
+
+// Rule Assignable
+ruleAssignable
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getAssignableAccess().getAlternatives()); }
+(rule__Assignable__Alternatives)
+{ after(grammarAccess.getAssignableAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleArg
+entryRuleArg
+:
+{ before(grammarAccess.getArgRule()); }
+ ruleArg
+{ after(grammarAccess.getArgRule()); }
+ EOF
+;
+
+// Rule Arg
+ruleArg
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getArgAccess().getGroup()); }
+(rule__Arg__Group__0)
+{ after(grammarAccess.getArgAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleArgLine
+entryRuleArgLine
+:
+{ before(grammarAccess.getArgLineRule()); }
+ ruleArgLine
+{ after(grammarAccess.getArgLineRule()); }
+ EOF
+;
+
+// Rule ArgLine
+ruleArgLine
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getArgLineAccess().getGroup()); }
+(rule__ArgLine__Group__0)
+{ after(grammarAccess.getArgLineAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleExplicitArgList
+entryRuleExplicitArgList
+:
+{ before(grammarAccess.getExplicitArgListRule()); }
+ ruleExplicitArgList
+{ after(grammarAccess.getExplicitArgListRule()); }
+ EOF
+;
+
+// Rule ExplicitArgList
+ruleExplicitArgList
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getExplicitArgListAccess().getGroup()); }
+(rule__ExplicitArgList__Group__0)
+{ after(grammarAccess.getExplicitArgListAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleArgList
+entryRuleArgList
+:
+{ before(grammarAccess.getArgListRule()); }
+ ruleArgList
+{ after(grammarAccess.getArgListRule()); }
+ EOF
+;
+
+// Rule ArgList
+ruleArgList
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getArgListAccess().getGroup()); }
+(rule__ArgList__Group__0)
+{ after(grammarAccess.getArgListAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleArray
+entryRuleArray
+:
+{ before(grammarAccess.getArrayRule()); }
+ ruleArray
+{ after(grammarAccess.getArrayRule()); }
+ EOF
+;
+
+// Rule Array
+ruleArray
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getArrayAccess().getGroup()); }
+(rule__Array__Group__0)
+{ after(grammarAccess.getArrayAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleDictionary
+entryRuleDictionary
+:
+{ before(grammarAccess.getDictionaryRule()); }
+ ruleDictionary
+{ after(grammarAccess.getDictionaryRule()); }
+ EOF
+;
+
+// Rule Dictionary
+ruleDictionary
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getDictionaryAccess().getGroup()); }
+(rule__Dictionary__Group__0)
+{ after(grammarAccess.getDictionaryAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleDictItems
+entryRuleDictItems
+:
+{ before(grammarAccess.getDictItemsRule()); }
+ ruleDictItems
+{ after(grammarAccess.getDictItemsRule()); }
+ EOF
+;
+
+// Rule DictItems
+ruleDictItems
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getDictItemsAccess().getGroup()); }
+(rule__DictItems__Group__0)
+{ after(grammarAccess.getDictItemsAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleExplicitDictItems
+entryRuleExplicitDictItems
+:
+{ before(grammarAccess.getExplicitDictItemsRule()); }
+ ruleExplicitDictItems
+{ after(grammarAccess.getExplicitDictItemsRule()); }
+ EOF
+;
+
+// Rule ExplicitDictItems
+ruleExplicitDictItems
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getGroup()); }
+(rule__ExplicitDictItems__Group__0)
+{ after(grammarAccess.getExplicitDictItemsAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleDictLine
+entryRuleDictLine
+:
+{ before(grammarAccess.getDictLineRule()); }
+ ruleDictLine
+{ after(grammarAccess.getDictLineRule()); }
+ EOF
+;
+
+// Rule DictLine
+ruleDictLine
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getDictLineAccess().getGroup()); }
+(rule__DictLine__Group__0)
+{ after(grammarAccess.getDictLineAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleDictItem
+entryRuleDictItem
+:
+{ before(grammarAccess.getDictItemRule()); }
+ ruleDictItem
+{ after(grammarAccess.getDictItemRule()); }
+ EOF
+;
+
+// Rule DictItem
+ruleDictItem
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getDictItemAccess().getGroup()); }
+(rule__DictItem__Group__0)
+{ after(grammarAccess.getDictItemAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleDictKey
+entryRuleDictKey
+:
+{ before(grammarAccess.getDictKeyRule()); }
+ ruleDictKey
+{ after(grammarAccess.getDictKeyRule()); }
+ EOF
+;
+
+// Rule DictKey
+ruleDictKey
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getDictKeyAccess().getAlternatives()); }
+(rule__DictKey__Alternatives)
+{ after(grammarAccess.getDictKeyAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLambda
+entryRuleLambda
+:
+{ before(grammarAccess.getLambdaRule()); }
+ ruleLambda
+{ after(grammarAccess.getLambdaRule()); }
+ EOF
+;
+
+// Rule Lambda
+ruleLambda
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLambdaAccess().getGroup()); }
+(rule__Lambda__Group__0)
+{ after(grammarAccess.getLambdaAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleParam
+entryRuleParam
+:
+{ before(grammarAccess.getParamRule()); }
+ ruleParam
+{ after(grammarAccess.getParamRule()); }
+ EOF
+;
+
+// Rule Param
+ruleParam
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getParamAccess().getGroup()); }
+(rule__Param__Group__0)
+{ after(grammarAccess.getParamAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNumberLiteral
+entryRuleNumberLiteral
+:
+{ before(grammarAccess.getNumberLiteralRule()); }
+ ruleNumberLiteral
+{ after(grammarAccess.getNumberLiteralRule()); }
+ EOF
+;
+
+// Rule NumberLiteral
+ruleNumberLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getNumberLiteralAccess().getGroup()); }
+(rule__NumberLiteral__Group__0)
+{ after(grammarAccess.getNumberLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStringLiteral
+entryRuleStringLiteral
+:
+{ before(grammarAccess.getStringLiteralRule()); }
+ ruleStringLiteral
+{ after(grammarAccess.getStringLiteralRule()); }
+ EOF
+;
+
+// Rule StringLiteral
+ruleStringLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getStringLiteralAccess().getGroup()); }
+(rule__StringLiteral__Group__0)
+{ after(grammarAccess.getStringLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBoolLiteral
+entryRuleBoolLiteral
+:
+{ before(grammarAccess.getBoolLiteralRule()); }
+ ruleBoolLiteral
+{ after(grammarAccess.getBoolLiteralRule()); }
+ EOF
+;
+
+// Rule BoolLiteral
+ruleBoolLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getBoolLiteralAccess().getGroup()); }
+(rule__BoolLiteral__Group__0)
+{ after(grammarAccess.getBoolLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleJSLiteral
+entryRuleJSLiteral
+:
+{ before(grammarAccess.getJSLiteralRule()); }
+ ruleJSLiteral
+{ after(grammarAccess.getJSLiteralRule()); }
+ EOF
+;
+
+// Rule JSLiteral
+ruleJSLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getJSLiteralAccess().getGroup()); }
+(rule__JSLiteral__Group__0)
+{ after(grammarAccess.getJSLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleRegexLiteral
+entryRuleRegexLiteral
+:
+{ before(grammarAccess.getRegexLiteralRule()); }
+ ruleRegexLiteral
+{ after(grammarAccess.getRegexLiteralRule()); }
+ EOF
+;
+
+// Rule RegexLiteral
+ruleRegexLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getRegexLiteralAccess().getGroup()); }
+(rule__RegexLiteral__Group__0)
+{ after(grammarAccess.getRegexLiteralAccess().getGroup()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLiteral
+entryRuleLiteral
+:
+{ before(grammarAccess.getLiteralRule()); }
+ ruleLiteral
+{ after(grammarAccess.getLiteralRule()); }
+ EOF
+;
+
+// Rule Literal
+ruleLiteral
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getLiteralAccess().getAlternatives()); }
+(rule__Literal__Alternatives)
+{ after(grammarAccess.getLiteralAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleParenthetical
+entryRuleParenthetical
+:
+{ before(grammarAccess.getParentheticalRule()); }
+ ruleParenthetical
+{ after(grammarAccess.getParentheticalRule()); }
+ EOF
+;
+
+// Rule Parenthetical
+ruleParenthetical
+ @init {
+ int stackSize = keepStackSize();
+ }
+ :
+(
+{ before(grammarAccess.getParentheticalAccess().getAlternatives()); }
+(rule__Parenthetical__Alternatives)
+{ after(grammarAccess.getParentheticalAccess().getAlternatives()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+rule__Line__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLineAccess().getStmtParserRuleCall_0()); }
+ ruleStmt
+{ after(grammarAccess.getLineAccess().getStmtParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getLineAccess().getExpressionParserRuleCall_1()); }
+ ruleExpression
+{ after(grammarAccess.getLineAccess().getExpressionParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Stmt__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0()); }
+ ruleReturnStmt
+{ after(grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1()); }
+ ruleThrowStmt
+{ after(grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2()); }
+( ruleRequireStmt)
+{ after(grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getStmtAccess().getCommentParserRuleCall_3()); }
+ ruleComment
+{ after(grammarAccess.getStmtAccess().getCommentParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4()); }
+ ruleClassDeclaration
+{ after(grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4()); }
+)
+
+ |(
+{ before(grammarAccess.getStmtAccess().getStatementAssignment_5()); }
+(rule__Stmt__StatementAssignment_5)
+{ after(grammarAccess.getStmtAccess().getStatementAssignment_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__SuperClass__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0()); }
+ ruleIdRef
+{ after(grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1()); }
+ ruleProperty
+{ after(grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_0()); }
+(rule__ClassDeclaration__BodyAssignment_2_0)
+{ after(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getClassDeclarationAccess().getGroup_2_1()); }
+(rule__ClassDeclaration__Group_2_1__0)
+{ after(grammarAccess.getClassDeclarationAccess().getGroup_2_1()); }
+)
+
+ |(
+{ before(grammarAccess.getClassDeclarationAccess().getGroup_2_2()); }
+(rule__ClassDeclaration__Group_2_2__0)
+{ after(grammarAccess.getClassDeclarationAccess().getGroup_2_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__NameAlternatives_2_2_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0()); }
+ ruleId
+{ after(grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1()); }
+ ruleProperty
+{ after(grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Alternatives_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_0()); }
+(rule__AssignedClassDeclaration__Group_2_0__0)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1()); }
+(rule__AssignedClassDeclaration__Group_2_1__0)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0()); }
+ ruleId
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1()); }
+ ruleProperty
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getGroup_1_0()); }
+(rule__Postfix__Group_1_0__0)
+{ after(grammarAccess.getPostfixAccess().getGroup_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getPostfixAccess().getGroup_1_1()); }
+(rule__Postfix__Group_1_1__0)
+{ after(grammarAccess.getPostfixAccess().getGroup_1_1()); }
+)
+
+ |(
+{ before(grammarAccess.getPostfixAccess().getGroup_1_2()); }
+(rule__Postfix__Group_1_2__0)
+{ after(grammarAccess.getPostfixAccess().getGroup_1_2()); }
+)
+
+ |(
+{ before(grammarAccess.getPostfixAccess().getGroup_1_3()); }
+(rule__Postfix__Group_1_3__0)
+{ after(grammarAccess.getPostfixAccess().getGroup_1_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getGroup_1_0()); }
+(rule__ForSource__Group_1_0__0)
+{ after(grammarAccess.getForSourceAccess().getGroup_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getForSourceAccess().getGroup_1_1()); }
+(rule__ForSource__Group_1_1__0)
+{ after(grammarAccess.getForSourceAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Alternatives_1_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getGroup_1_1_2_0()); }
+(rule__ForSource__Group_1_1_2_0__0)
+{ after(grammarAccess.getForSourceAccess().getGroup_1_1_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getForSourceAccess().getGroup_1_1_2_1()); }
+(rule__ForSource__Group_1_1_2_1__0)
+{ after(grammarAccess.getForSourceAccess().getGroup_1_1_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__Alternatives_0_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0()); }
+ RULE_DOT_DOT
+{ after(grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getRangeAccess().getELLIPSISTerminalRuleCall_0_0_2_1()); }
+ RULE_ELLIPSIS
+{ after(grammarAccess.getRangeAccess().getELLIPSISTerminalRuleCall_0_0_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getGroup_0()); }
+(rule__Assignment__Group_0__0)
+{ after(grammarAccess.getAssignmentAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1()); }
+ ruleLogicOp
+{ after(grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__OperatorAlternatives_0_0_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0()); }
+ RULE_EQUAL
+{ after(grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1()); }
+ RULE_COMPOUND_ASSIGN
+{ after(grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assigned__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0()); }
+ ruleExpression
+{ after(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignedAccess().getGroup_1()); }
+(rule__Assigned__Group_1__0)
+{ after(grammarAccess.getAssignedAccess().getGroup_1()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2()); }
+ ruleAssignedClassDeclaration
+{ after(grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0()); }
+ RULE_PLUS
+{ after(grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1()); }
+ RULE_MINUS
+{ after(grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryOp__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryOpAccess().getGroup_0()); }
+(rule__UnaryOp__Group_0__0)
+{ after(grammarAccess.getUnaryOpAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getUnaryOpAccess().getGroup_1()); }
+(rule__UnaryOp__Group_1__0)
+{ after(grammarAccess.getUnaryOpAccess().getGroup_1()); }
+)
+
+ |(
+{ before(grammarAccess.getUnaryOpAccess().getGroup_2()); }
+(rule__UnaryOp__Group_2__0)
+{ after(grammarAccess.getUnaryOpAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryOp__Alternatives_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0()); }
+ RULE_UNARY
+{ after(grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getUnaryOpAccess().getPLUSTerminalRuleCall_0_0_1()); }
+ RULE_PLUS
+{ after(grammarAccess.getUnaryOpAccess().getPLUSTerminalRuleCall_0_0_1()); }
+)
+
+ |(
+{ before(grammarAccess.getUnaryOpAccess().getMINUSTerminalRuleCall_0_0_2()); }
+ RULE_MINUS
+{ after(grammarAccess.getUnaryOpAccess().getMINUSTerminalRuleCall_0_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryOp__Alternatives_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0()); }
+ RULE_PLUS_PLUS
+{ after(grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getUnaryOpAccess().getMINUS_MINUSTerminalRuleCall_1_0_1()); }
+ RULE_MINUS_MINUS
+{ after(grammarAccess.getUnaryOpAccess().getMINUS_MINUSTerminalRuleCall_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getGroup_0()); }
+(rule__Application__Group_0__0)
+{ after(grammarAccess.getApplicationAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getApplicationAccess().getGroup_1()); }
+(rule__Application__Group_1__0)
+{ after(grammarAccess.getApplicationAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FeatureCall__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0()); }
+ ruleFunctionCall
+{ after(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1()); }
+ rulePropertyAccess
+{ after(grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PropertyAccess__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0()); }
+ ruleNamedPropertyAccess
+{ after(grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1()); }
+ ruleIndexedPropertyAccess
+{ after(grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getGroup_0()); }
+(rule__NamedPropertyAccess__Group_0__0)
+{ after(grammarAccess.getNamedPropertyAccessAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getGroup_1()); }
+(rule__NamedPropertyAccess__Group_1__0)
+{ after(grammarAccess.getNamedPropertyAccessAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__AccessorAlternatives_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0()); }
+ RULE_DOT
+{ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1()); }
+ RULE_QUESTION_DOT
+{ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getGroup_0()); }
+(rule__Index__Group_0__0)
+{ after(grammarAccess.getIndexAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getIndexAccess().getGroup_1()); }
+(rule__Index__Group_1__0)
+{ after(grammarAccess.getIndexAccess().getGroup_1()); }
+)
+
+ |(
+{ before(grammarAccess.getIndexAccess().getExpAssignment_2()); }
+(rule__Index__ExpAssignment_2)
+{ after(grammarAccess.getIndexAccess().getExpAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__DotsAlternatives_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0()); }
+ RULE_DOT_DOT
+{ after(grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1()); }
+ RULE_ELLIPSIS
+{ after(grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__DotsAlternatives_1_0_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0()); }
+ RULE_DOT_DOT
+{ after(grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1()); }
+ RULE_ELLIPSIS
+{ after(grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0()); }
+ ruleIfExp
+{ after(grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1()); }
+ ruleParenthetical
+{ after(grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2()); }
+ ruleLiteral
+{ after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3()); }
+( ruleRange)
+{ after(grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4()); }
+( ruleArray)
+{ after(grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5()); }
+( ruleDictionary)
+{ after(grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6()); }
+ ruleLambda
+{ after(grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7()); }
+ ruleThisProperty
+{ after(grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_8()); }
+(rule__PrimaryExpression__Group_8__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_8()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_9()); }
+(rule__PrimaryExpression__Group_9__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_9()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_10()); }
+(rule__PrimaryExpression__Group_10__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_10()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_11()); }
+(rule__PrimaryExpression__Group_11__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_11()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_12()); }
+(rule__PrimaryExpression__Group_12__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_12()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13()); }
+(rule__PrimaryExpression__Group_13__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_14()); }
+(rule__PrimaryExpression__Group_14__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_14()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15()); }
+ ruleIdRef
+{ after(grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Alternatives_13_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0()); }
+(rule__PrimaryExpression__Group_13_1_2_0__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0()); }
+)
+
+ |(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_1()); }
+(rule__PrimaryExpression__Group_13_1_2_1__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getGroup_0()); }
+(rule__Property__Group_0__0)
+{ after(grammarAccess.getPropertyAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyAccess().getGroup_1()); }
+(rule__Property__Group_1__0)
+{ after(grammarAccess.getPropertyAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__AccessorAlternatives_0_0_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0()); }
+ RULE_DOT
+{ after(grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1()); }
+ RULE_DOUBLE_COLON
+{ after(grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1()); }
+)
+
+ |(
+{ before(grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2()); }
+ RULE_QUESTION_DOT
+{ after(grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getIdParserRuleCall_0()); }
+ ruleId
+{ after(grammarAccess.getVariableAccess().getIdParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getVariableAccess().getGroup_1()); }
+(rule__Variable__Group_1__0)
+{ after(grammarAccess.getVariableAccess().getGroup_1()); }
+)
+
+ |(
+{ before(grammarAccess.getVariableAccess().getPropertyParserRuleCall_2()); }
+ ruleProperty
+{ after(grammarAccess.getVariableAccess().getPropertyParserRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__Alternatives_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0()); }
+ RULE_AT_SIGIL
+{ after(grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getVariableAccess().getGroup_1_0_1()); }
+(rule__Variable__Group_1_0_1__0)
+{ after(grammarAccess.getVariableAccess().getGroup_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignable__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableAccess().getVariableParserRuleCall_0()); }
+ ruleVariable
+{ after(grammarAccess.getAssignableAccess().getVariableParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1()); }
+( ruleDictionary)
+{ after(grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2()); }
+( ruleAssignableArray)
+{ after(grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getGroup_1_0()); }
+(rule__ExplicitArgList__Group_1_0__0)
+{ after(grammarAccess.getExplicitArgListAccess().getGroup_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getExplicitArgListAccess().getGroup_1_1()); }
+(rule__ExplicitArgList__Group_1_1__0)
+{ after(grammarAccess.getExplicitArgListAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgList__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgListAccess().getDummyAssignment_1_0()); }
+(rule__ArgList__DummyAssignment_1_0)
+{ after(grammarAccess.getArgListAccess().getDummyAssignment_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getArgListAccess().getGroup_1_1()); }
+(rule__ArgList__Group_1_1__0)
+{ after(grammarAccess.getArgListAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItems__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemsAccess().getDummyAssignment_1_0()); }
+(rule__DictItems__DummyAssignment_1_0)
+{ after(grammarAccess.getDictItemsAccess().getDummyAssignment_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getDictItemsAccess().getGroup_1_1()); }
+(rule__DictItems__Group_1_1__0)
+{ after(grammarAccess.getDictItemsAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getGroup_1_0()); }
+(rule__ExplicitDictItems__Group_1_0__0)
+{ after(grammarAccess.getExplicitDictItemsAccess().getGroup_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getExplicitDictItemsAccess().getGroup_1_1()); }
+(rule__ExplicitDictItems__Group_1_1__0)
+{ after(grammarAccess.getExplicitDictItemsAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__Alternatives_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getValueAssignment_2_1_0()); }
+(rule__DictItem__ValueAssignment_2_1_0)
+{ after(grammarAccess.getDictItemAccess().getValueAssignment_2_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getDictItemAccess().getGroup_2_1_1()); }
+(rule__DictItem__Group_2_1_1__0)
+{ after(grammarAccess.getDictItemAccess().getGroup_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictKey__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0()); }
+ ruleLiteral
+{ after(grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getDictKeyAccess().getIdParserRuleCall_1()); }
+ ruleId
+{ after(grammarAccess.getDictKeyAccess().getIdParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0()); }
+ RULE_FUNC_ARROW
+{ after(grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getLambdaAccess().getBOUND_FUNC_ARROWTerminalRuleCall_1_1()); }
+ RULE_BOUND_FUNC_ARROW
+{ after(grammarAccess.getLambdaAccess().getBOUND_FUNC_ARROWTerminalRuleCall_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Param__Alternatives_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParamAccess().getIdParserRuleCall_0_0()); }
+ ruleId
+{ after(grammarAccess.getParamAccess().getIdParserRuleCall_0_0()); }
+)
+
+ |(
+{ before(grammarAccess.getParamAccess().getArrayParserRuleCall_0_1()); }
+( ruleArray)
+{ after(grammarAccess.getParamAccess().getArrayParserRuleCall_0_1()); }
+)
+
+ |(
+{ before(grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2()); }
+( ruleDictionary)
+{ after(grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2()); }
+)
+
+ |(
+{ before(grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3()); }
+ ruleThisProperty
+{ after(grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Param__Alternatives_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParamAccess().getSplatAssignment_1_0()); }
+(rule__Param__SplatAssignment_1_0)
+{ after(grammarAccess.getParamAccess().getSplatAssignment_1_0()); }
+)
+
+ |(
+{ before(grammarAccess.getParamAccess().getGroup_1_1()); }
+(rule__Param__Group_1_1__0)
+{ after(grammarAccess.getParamAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Literal__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0()); }
+ ruleNumberLiteral
+{ after(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0()); }
+)
+
+ |(
+{ before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1()); }
+ ruleStringLiteral
+{ after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1()); }
+)
+
+ |(
+{ before(grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2()); }
+ ruleBoolLiteral
+{ after(grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2()); }
+)
+
+ |(
+{ before(grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3()); }
+ ruleJSLiteral
+{ after(grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3()); }
+)
+
+ |(
+{ before(grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4()); }
+ ruleRegexLiteral
+{ after(grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Alternatives
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getGroup_0()); }
+(rule__Parenthetical__Group_0__0)
+{ after(grammarAccess.getParentheticalAccess().getGroup_0()); }
+)
+
+ |(
+{ before(grammarAccess.getParentheticalAccess().getGroup_1()); }
+(rule__Parenthetical__Group_1__0)
+{ after(grammarAccess.getParentheticalAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+rule__TaskDeclaration__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__0__Impl
+ rule__TaskDeclaration__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getTASKTerminalRuleCall_0()); }
+ RULE_TASK
+{ after(grammarAccess.getTaskDeclarationAccess().getTASKTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__1__Impl
+ rule__TaskDeclaration__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getCALL_STARTTerminalRuleCall_1()); }
+ RULE_CALL_START
+{ after(grammarAccess.getTaskDeclarationAccess().getCALL_STARTTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__2__Impl
+ rule__TaskDeclaration__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getNameAssignment_2()); }
+(rule__TaskDeclaration__NameAssignment_2)
+{ after(grammarAccess.getTaskDeclarationAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__3__Impl
+ rule__TaskDeclaration__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_3()); }
+ RULE_COMMA
+{ after(grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__4__Impl
+ rule__TaskDeclaration__Group__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getDescriptionAssignment_4()); }
+(rule__TaskDeclaration__DescriptionAssignment_4)
+{ after(grammarAccess.getTaskDeclarationAccess().getDescriptionAssignment_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__5__Impl
+ rule__TaskDeclaration__Group__6
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_5()); }
+ RULE_COMMA
+{ after(grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__6
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__6__Impl
+ rule__TaskDeclaration__Group__7
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__6__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getGroup_6()); }
+(rule__TaskDeclaration__Group_6__0)?
+{ after(grammarAccess.getTaskDeclarationAccess().getGroup_6()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__7
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__7__Impl
+ rule__TaskDeclaration__Group__8
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__7__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getFUNC_ARROWTerminalRuleCall_7()); }
+ RULE_FUNC_ARROW
+{ after(grammarAccess.getTaskDeclarationAccess().getFUNC_ARROWTerminalRuleCall_7()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__8
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__8__Impl
+ rule__TaskDeclaration__Group__9
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__8__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getBodyAssignment_8()); }
+(rule__TaskDeclaration__BodyAssignment_8)
+{ after(grammarAccess.getTaskDeclarationAccess().getBodyAssignment_8()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__9
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__9__Impl
+ rule__TaskDeclaration__Group__10
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__9__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getCALL_ENDTerminalRuleCall_9()); }
+ RULE_CALL_END
+{ after(grammarAccess.getTaskDeclarationAccess().getCALL_ENDTerminalRuleCall_9()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group__10
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group__10__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group__10__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getTERMINATORTerminalRuleCall_10()); }
+ RULE_TERMINATOR
+{ after(grammarAccess.getTaskDeclarationAccess().getTERMINATORTerminalRuleCall_10()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TaskDeclaration__Group_6__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group_6__0__Impl
+ rule__TaskDeclaration__Group_6__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group_6__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getPARAM_STARTTerminalRuleCall_6_0()); }
+ RULE_PARAM_START
+{ after(grammarAccess.getTaskDeclarationAccess().getPARAM_STARTTerminalRuleCall_6_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group_6__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group_6__1__Impl
+ rule__TaskDeclaration__Group_6__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group_6__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getOptionsAssignment_6_1()); }
+(rule__TaskDeclaration__OptionsAssignment_6_1)
+{ after(grammarAccess.getTaskDeclarationAccess().getOptionsAssignment_6_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__TaskDeclaration__Group_6__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__TaskDeclaration__Group_6__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__Group_6__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getPARAM_ENDTerminalRuleCall_6_2()); }
+ RULE_PARAM_END
+{ after(grammarAccess.getTaskDeclarationAccess().getPARAM_ENDTerminalRuleCall_6_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+rule__Body__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Body__Group__0__Impl
+ rule__Body__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Body__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBodyAccess().getLinesAssignment_0()); }
+(rule__Body__LinesAssignment_0)
+{ after(grammarAccess.getBodyAccess().getLinesAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Body__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Body__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Body__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBodyAccess().getGroup_1()); }
+(rule__Body__Group_1__0)*
+{ after(grammarAccess.getBodyAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Body__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Body__Group_1__0__Impl
+ rule__Body__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Body__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0()); }
+ RULE_TERMINATOR
+{ after(grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Body__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Body__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Body__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBodyAccess().getLinesAssignment_1_1()); }
+(rule__Body__LinesAssignment_1_1)?
+{ after(grammarAccess.getBodyAccess().getLinesAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__RequireStmt__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RequireStmt__Group__0__Impl
+ rule__RequireStmt__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getGroup_0()); }
+(rule__RequireStmt__Group_0__0)
+{ after(grammarAccess.getRequireStmtAccess().getGroup_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RequireStmt__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RequireStmt__Group__1__Impl
+ rule__RequireStmt__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1()); }
+ RULE_CALL_START
+{ after(grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RequireStmt__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RequireStmt__Group__2__Impl
+ rule__RequireStmt__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getUriAssignment_2()); }
+(rule__RequireStmt__UriAssignment_2)
+{ after(grammarAccess.getRequireStmtAccess().getUriAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RequireStmt__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RequireStmt__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3()); }
+ RULE_CALL_END
+{ after(grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__RequireStmt__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RequireStmt__Group_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getGroup_0_0()); }
+(rule__RequireStmt__Group_0_0__0)
+{ after(grammarAccess.getRequireStmtAccess().getGroup_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__RequireStmt__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RequireStmt__Group_0_0__0__Impl
+ rule__RequireStmt__Group_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getImportedNamespaceAssignment_0_0_0()); }
+(rule__RequireStmt__ImportedNamespaceAssignment_0_0_0)
+{ after(grammarAccess.getRequireStmtAccess().getImportedNamespaceAssignment_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RequireStmt__Group_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RequireStmt__Group_0_0__1__Impl
+ rule__RequireStmt__Group_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__Group_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1()); }
+ RULE_EQUAL
+{ after(grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RequireStmt__Group_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RequireStmt__Group_0_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__Group_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2()); }
+
+ 'require'
+
+{ after(grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ReturnStmt__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReturnStmt__Group__0__Impl
+ rule__ReturnStmt__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStmt__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStmtAccess().getReturnStmtAction_0()); }
+(
+
+)
+{ after(grammarAccess.getReturnStmtAccess().getReturnStmtAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ReturnStmt__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReturnStmt__Group__1__Impl
+ rule__ReturnStmt__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStmt__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1()); }
+ RULE_RETURN
+{ after(grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ReturnStmt__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReturnStmt__Group__2__Impl
+ rule__ReturnStmt__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStmt__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStmtAccess().getExpressionAssignment_2()); }
+(rule__ReturnStmt__ExpressionAssignment_2)?
+{ after(grammarAccess.getReturnStmtAccess().getExpressionAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ReturnStmt__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReturnStmt__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStmt__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStmtAccess().getGroup_3()); }
+(rule__ReturnStmt__Group_3__0)?
+{ after(grammarAccess.getReturnStmtAccess().getGroup_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__ReturnStmt__Group_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReturnStmt__Group_3__0__Impl
+ rule__ReturnStmt__Group_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStmt__Group_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0()); }
+ RULE_POST_IF
+{ after(grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ReturnStmt__Group_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ReturnStmt__Group_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStmt__Group_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStmtAccess().getConditionAssignment_3_1()); }
+(rule__ReturnStmt__ConditionAssignment_3_1)
+{ after(grammarAccess.getReturnStmtAccess().getConditionAssignment_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ThrowStmt__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThrowStmt__Group__0__Impl
+ rule__ThrowStmt__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThrowStmt__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0()); }
+ RULE_THROW
+{ after(grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ThrowStmt__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThrowStmt__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThrowStmt__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThrowStmtAccess().getExpAssignment_1()); }
+(rule__ThrowStmt__ExpAssignment_1)
+{ after(grammarAccess.getThrowStmtAccess().getExpAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassDeclaration__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group__0__Impl
+ rule__ClassDeclaration__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0()); }
+(
+
+)
+{ after(grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassDeclaration__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group__1__Impl
+ rule__ClassDeclaration__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1()); }
+ RULE_CLASS
+{ after(grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassDeclaration__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getAlternatives_2()); }
+(rule__ClassDeclaration__Alternatives_2)?
+{ after(grammarAccess.getClassDeclarationAccess().getAlternatives_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ClassDeclaration__Group_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group_2_1__0__Impl
+ rule__ClassDeclaration__Group_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0()); }
+ RULE_EXTENDS
+{ after(grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassDeclaration__Group_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group_2_1__1__Impl
+ rule__ClassDeclaration__Group_2_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_1_1()); }
+(rule__ClassDeclaration__ExtendAssignment_2_1_1)
+{ after(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassDeclaration__Group_2_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group_2_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group_2_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_1_2()); }
+(rule__ClassDeclaration__BodyAssignment_2_1_2)?
+{ after(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ClassDeclaration__Group_2_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group_2_2__0__Impl
+ rule__ClassDeclaration__Group_2_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group_2_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2_2_0()); }
+(rule__ClassDeclaration__NameAssignment_2_2_0)
+{ after(grammarAccess.getClassDeclarationAccess().getNameAssignment_2_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassDeclaration__Group_2_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group_2_2__1__Impl
+ rule__ClassDeclaration__Group_2_2__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group_2_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getGroup_2_2_1()); }
+(rule__ClassDeclaration__Group_2_2_1__0)?
+{ after(grammarAccess.getClassDeclarationAccess().getGroup_2_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassDeclaration__Group_2_2__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group_2_2__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group_2_2__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_2_2()); }
+(rule__ClassDeclaration__BodyAssignment_2_2_2)
+{ after(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_2_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ClassDeclaration__Group_2_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group_2_2_1__0__Impl
+ rule__ClassDeclaration__Group_2_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group_2_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0()); }
+ RULE_EXTENDS
+{ after(grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ClassDeclaration__Group_2_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ClassDeclaration__Group_2_2_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__Group_2_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_2_1_1()); }
+(rule__ClassDeclaration__ExtendAssignment_2_2_1_1)
+{ after(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AssignedClassDeclaration__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group__0__Impl
+ rule__AssignedClassDeclaration__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0()); }
+(
+
+)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignedClassDeclaration__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group__1__Impl
+ rule__AssignedClassDeclaration__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1()); }
+ RULE_CLASS
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignedClassDeclaration__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getAlternatives_2()); }
+(rule__AssignedClassDeclaration__Alternatives_2)?
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getAlternatives_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__AssignedClassDeclaration__Group_2_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group_2_0__0__Impl
+ rule__AssignedClassDeclaration__Group_2_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group_2_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0()); }
+ RULE_EXTENDS
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignedClassDeclaration__Group_2_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group_2_0__1__Impl
+ rule__AssignedClassDeclaration__Group_2_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group_2_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_0_1()); }
+(rule__AssignedClassDeclaration__ExtendAssignment_2_0_1)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignedClassDeclaration__Group_2_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group_2_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group_2_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_0_2()); }
+(rule__AssignedClassDeclaration__BodyAssignment_2_0_2)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__AssignedClassDeclaration__Group_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group_2_1__0__Impl
+ rule__AssignedClassDeclaration__Group_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getNameAssignment_2_1_0()); }
+(rule__AssignedClassDeclaration__NameAssignment_2_1_0)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getNameAssignment_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignedClassDeclaration__Group_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group_2_1__1__Impl
+ rule__AssignedClassDeclaration__Group_2_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1_1()); }
+(rule__AssignedClassDeclaration__Group_2_1_1__0)?
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignedClassDeclaration__Group_2_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group_2_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group_2_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_1_2()); }
+(rule__AssignedClassDeclaration__BodyAssignment_2_1_2)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__AssignedClassDeclaration__Group_2_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group_2_1_1__0__Impl
+ rule__AssignedClassDeclaration__Group_2_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group_2_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0()); }
+ RULE_EXTENDS
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignedClassDeclaration__Group_2_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignedClassDeclaration__Group_2_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__Group_2_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_1_1_1()); }
+(rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Postfix__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group__0__Impl
+ rule__Postfix__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0()); }
+ ruleAssignment
+{ after(grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getAlternatives_1()); }
+(rule__Postfix__Alternatives_1)?
+{ after(grammarAccess.getPostfixAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Postfix__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_0__0__Impl
+ rule__Postfix__Group_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0()); }
+( RULE_POST_IF)
+{ after(grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_0__1__Impl
+ rule__Postfix__Group_1_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1()); }
+(
+
+)
+{ after(grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getConditionAssignment_1_0_2()); }
+(rule__Postfix__ConditionAssignment_1_0_2)
+{ after(grammarAccess.getPostfixAccess().getConditionAssignment_1_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Postfix__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_1__0__Impl
+ rule__Postfix__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0()); }
+( RULE_FOR)
+{ after(grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_1__1__Impl
+ rule__Postfix__Group_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getForDummyAction_1_1_1()); }
+(
+
+)
+{ after(grammarAccess.getPostfixAccess().getForDummyAction_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getBodyAssignment_1_1_2()); }
+(rule__Postfix__BodyAssignment_1_1_2)
+{ after(grammarAccess.getPostfixAccess().getBodyAssignment_1_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Postfix__Group_1_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_2__0__Impl
+ rule__Postfix__Group_1_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0()); }
+( RULE_WHILE)
+{ after(grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_2__1__Impl
+ rule__Postfix__Group_1_2__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1()); }
+(
+
+)
+{ after(grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_2__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_2__2__Impl
+ rule__Postfix__Group_1_2__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_2__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getBodyAssignment_1_2_2()); }
+(rule__Postfix__BodyAssignment_1_2_2)
+{ after(grammarAccess.getPostfixAccess().getBodyAssignment_1_2_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_2__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_2__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_2__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getGroup_1_2_3()); }
+(rule__Postfix__Group_1_2_3__0)?
+{ after(grammarAccess.getPostfixAccess().getGroup_1_2_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Postfix__Group_1_2_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_2_3__0__Impl
+ rule__Postfix__Group_1_2_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_2_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0()); }
+( RULE_WHEN)
+{ after(grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_2_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_2_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_2_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getWhenAssignment_1_2_3_1()); }
+(rule__Postfix__WhenAssignment_1_2_3_1)
+{ after(grammarAccess.getPostfixAccess().getWhenAssignment_1_2_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Postfix__Group_1_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_3__0__Impl
+ rule__Postfix__Group_1_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0()); }
+( RULE_UNTIL)
+{ after(grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_3__1__Impl
+ rule__Postfix__Group_1_3__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1()); }
+(
+
+)
+{ after(grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_3__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_3__2__Impl
+ rule__Postfix__Group_1_3__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_3__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getBodyAssignment_1_3_2()); }
+(rule__Postfix__BodyAssignment_1_3_2)
+{ after(grammarAccess.getPostfixAccess().getBodyAssignment_1_3_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_3__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_3__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_3__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getGroup_1_3_3()); }
+(rule__Postfix__Group_1_3_3__0)?
+{ after(grammarAccess.getPostfixAccess().getGroup_1_3_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Postfix__Group_1_3_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_3_3__0__Impl
+ rule__Postfix__Group_1_3_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_3_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0()); }
+( RULE_WHEN)
+{ after(grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Postfix__Group_1_3_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Postfix__Group_1_3_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__Group_1_3_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getWhenAssignment_1_3_3_1()); }
+(rule__Postfix__WhenAssignment_1_3_3_1)
+{ after(grammarAccess.getPostfixAccess().getWhenAssignment_1_3_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ForBody__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForBody__Group__0__Impl
+ rule__ForBody__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForBody__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForBodyAccess().getOWNTerminalRuleCall_0()); }
+( RULE_OWN)?
+{ after(grammarAccess.getForBodyAccess().getOWNTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForBody__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForBody__Group__1__Impl
+ rule__ForBody__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForBody__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForBodyAccess().getIndexesAssignment_1()); }
+(rule__ForBody__IndexesAssignment_1)
+{ after(grammarAccess.getForBodyAccess().getIndexesAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForBody__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForBody__Group__2__Impl
+ rule__ForBody__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForBody__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForBodyAccess().getGroup_2()); }
+(rule__ForBody__Group_2__0)*
+{ after(grammarAccess.getForBodyAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForBody__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForBody__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForBody__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForBodyAccess().getSourceAssignment_3()); }
+(rule__ForBody__SourceAssignment_3)
+{ after(grammarAccess.getForBodyAccess().getSourceAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__ForBody__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForBody__Group_2__0__Impl
+ rule__ForBody__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForBody__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0()); }
+ RULE_COMMA
+{ after(grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForBody__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForBody__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForBody__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForBodyAccess().getIndexesAssignment_2_1()); }
+(rule__ForBody__IndexesAssignment_2_1)
+{ after(grammarAccess.getForBodyAccess().getIndexesAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ForSource__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group__0__Impl
+ rule__ForSource__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getForSourceAction_0()); }
+(
+
+)
+{ after(grammarAccess.getForSourceAccess().getForSourceAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getAlternatives_1()); }
+(rule__ForSource__Alternatives_1)
+{ after(grammarAccess.getForSourceAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ForSource__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_0__0__Impl
+ rule__ForSource__Group_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0()); }
+( RULE_FOROF)
+{ after(grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_0__1__Impl
+ rule__ForSource__Group_1_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getSourceAssignment_1_0_1()); }
+(rule__ForSource__SourceAssignment_1_0_1)
+{ after(grammarAccess.getForSourceAccess().getSourceAssignment_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getGroup_1_0_2()); }
+(rule__ForSource__Group_1_0_2__0)?
+{ after(grammarAccess.getForSourceAccess().getGroup_1_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ForSource__Group_1_0_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_0_2__0__Impl
+ rule__ForSource__Group_1_0_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_0_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0()); }
+( RULE_WHEN)
+{ after(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_0_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_0_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_0_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getWhenAssignment_1_0_2_1()); }
+(rule__ForSource__WhenAssignment_1_0_2_1)
+{ after(grammarAccess.getForSourceAccess().getWhenAssignment_1_0_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ForSource__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1__0__Impl
+ rule__ForSource__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0()); }
+( RULE_FORIN)
+{ after(grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1__1__Impl
+ rule__ForSource__Group_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getSourceAssignment_1_1_1()); }
+(rule__ForSource__SourceAssignment_1_1_1)
+{ after(grammarAccess.getForSourceAccess().getSourceAssignment_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getAlternatives_1_1_2()); }
+(rule__ForSource__Alternatives_1_1_2)?
+{ after(grammarAccess.getForSourceAccess().getAlternatives_1_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ForSource__Group_1_1_2_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_0__0__Impl
+ rule__ForSource__Group_1_1_2_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0()); }
+( RULE_WHEN)
+{ after(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_1_2_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_0__1__Impl
+ rule__ForSource__Group_1_1_2_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_0_1()); }
+(rule__ForSource__WhenAssignment_1_1_2_0_1)
+{ after(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_1_2_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getGroup_1_1_2_0_2()); }
+(rule__ForSource__Group_1_1_2_0_2__0)?
+{ after(grammarAccess.getForSourceAccess().getGroup_1_1_2_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ForSource__Group_1_1_2_0_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_0_2__0__Impl
+ rule__ForSource__Group_1_1_2_0_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_0_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0()); }
+( RULE_BY)
+{ after(grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_1_2_0_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_0_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_0_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_0_2_1()); }
+(rule__ForSource__ByAssignment_1_1_2_0_2_1)
+{ after(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_0_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ForSource__Group_1_1_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_1__0__Impl
+ rule__ForSource__Group_1_1_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0()); }
+( RULE_BY)
+{ after(grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_1_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_1__1__Impl
+ rule__ForSource__Group_1_1_2_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_1_1()); }
+(rule__ForSource__ByAssignment_1_1_2_1_1)
+{ after(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_1_2_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getGroup_1_1_2_1_2()); }
+(rule__ForSource__Group_1_1_2_1_2__0)?
+{ after(grammarAccess.getForSourceAccess().getGroup_1_1_2_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ForSource__Group_1_1_2_1_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_1_2__0__Impl
+ rule__ForSource__Group_1_1_2_1_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_1_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0()); }
+( RULE_WHEN)
+{ after(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ForSource__Group_1_1_2_1_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ForSource__Group_1_1_2_1_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__Group_1_1_2_1_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_1_2_1()); }
+(rule__ForSource__WhenAssignment_1_1_2_1_2_1)
+{ after(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_1_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Range__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Range__Group__0__Impl
+ rule__Range__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getGroup_0()); }
+(rule__Range__Group_0__0)
+{ after(grammarAccess.getRangeAccess().getGroup_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Range__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Range__Group__1__Impl
+ rule__Range__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getEndAssignment_1()); }
+(rule__Range__EndAssignment_1)
+{ after(grammarAccess.getRangeAccess().getEndAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Range__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Range__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2()); }
+ RULE_RBRACKET
+{ after(grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Range__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Range__Group_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getGroup_0_0()); }
+(rule__Range__Group_0_0__0)
+{ after(grammarAccess.getRangeAccess().getGroup_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__Range__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Range__Group_0_0__0__Impl
+ rule__Range__Group_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0()); }
+ RULE_LBRACKET
+{ after(grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Range__Group_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Range__Group_0_0__1__Impl
+ rule__Range__Group_0_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__Group_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getStartAssignment_0_0_1()); }
+(rule__Range__StartAssignment_0_0_1)
+{ after(grammarAccess.getRangeAccess().getStartAssignment_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Range__Group_0_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Range__Group_0_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__Group_0_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getAlternatives_0_0_2()); }
+(rule__Range__Alternatives_0_0_2)
+{ after(grammarAccess.getRangeAccess().getAlternatives_0_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Assignment__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Assignment__Group_0__0__Impl
+ rule__Assignment__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getGroup_0_0()); }
+(rule__Assignment__Group_0_0__0)
+{ after(grammarAccess.getAssignmentAccess().getGroup_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Assignment__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Assignment__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getRightAssignment_0_1()); }
+(rule__Assignment__RightAssignment_0_1)
+{ after(grammarAccess.getAssignmentAccess().getRightAssignment_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Assignment__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Assignment__Group_0_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getGroup_0_0_0()); }
+(rule__Assignment__Group_0_0_0__0)
+{ after(grammarAccess.getAssignmentAccess().getGroup_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__Assignment__Group_0_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Assignment__Group_0_0_0__0__Impl
+ rule__Assignment__Group_0_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__Group_0_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getLeftAssignment_0_0_0_0()); }
+(rule__Assignment__LeftAssignment_0_0_0_0)
+{ after(grammarAccess.getAssignmentAccess().getLeftAssignment_0_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Assignment__Group_0_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Assignment__Group_0_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__Group_0_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getOperatorAssignment_0_0_0_1()); }
+(rule__Assignment__OperatorAssignment_0_0_0_1)
+{ after(grammarAccess.getAssignmentAccess().getOperatorAssignment_0_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Assigned__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Assigned__Group_1__0__Impl
+ rule__Assigned__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assigned__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0()); }
+ RULE_INDENT
+{ after(grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Assigned__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Assigned__Group_1__1__Impl
+ rule__Assigned__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assigned__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1()); }
+ ruleExpression
+{ after(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Assigned__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Assigned__Group_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assigned__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2()); }
+ RULE_OUTDENT
+{ after(grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__LogicOp__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LogicOp__Group__0__Impl
+ rule__LogicOp__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LogicOp__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0()); }
+ ruleCompareOp
+{ after(grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LogicOp__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LogicOp__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LogicOp__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLogicOpAccess().getGroup_1()); }
+(rule__LogicOp__Group_1__0)*
+{ after(grammarAccess.getLogicOpAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LogicOp__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LogicOp__Group_1__0__Impl
+ rule__LogicOp__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LogicOp__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLogicOpAccess().getGroup_1_0()); }
+(rule__LogicOp__Group_1_0__0)
+{ after(grammarAccess.getLogicOpAccess().getGroup_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LogicOp__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LogicOp__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LogicOp__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLogicOpAccess().getRightAssignment_1_1()); }
+(rule__LogicOp__RightAssignment_1_1)
+{ after(grammarAccess.getLogicOpAccess().getRightAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LogicOp__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LogicOp__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LogicOp__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLogicOpAccess().getGroup_1_0_0()); }
+(rule__LogicOp__Group_1_0_0__0)
+{ after(grammarAccess.getLogicOpAccess().getGroup_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__LogicOp__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LogicOp__Group_1_0_0__0__Impl
+ rule__LogicOp__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LogicOp__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+(
+
+)
+{ after(grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__LogicOp__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__LogicOp__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LogicOp__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLogicOpAccess().getOperatorAssignment_1_0_0_1()); }
+(rule__LogicOp__OperatorAssignment_1_0_0_1)
+{ after(grammarAccess.getLogicOpAccess().getOperatorAssignment_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__CompareOp__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompareOp__Group__0__Impl
+ rule__CompareOp__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompareOp__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0()); }
+ ruleRelationOp
+{ after(grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CompareOp__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompareOp__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompareOp__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompareOpAccess().getGroup_1()); }
+(rule__CompareOp__Group_1__0)*
+{ after(grammarAccess.getCompareOpAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__CompareOp__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompareOp__Group_1__0__Impl
+ rule__CompareOp__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompareOp__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompareOpAccess().getGroup_1_0()); }
+(rule__CompareOp__Group_1_0__0)
+{ after(grammarAccess.getCompareOpAccess().getGroup_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CompareOp__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompareOp__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompareOp__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompareOpAccess().getRightAssignment_1_1()); }
+(rule__CompareOp__RightAssignment_1_1)
+{ after(grammarAccess.getCompareOpAccess().getRightAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__CompareOp__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompareOp__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompareOp__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompareOpAccess().getGroup_1_0_0()); }
+(rule__CompareOp__Group_1_0_0__0)
+{ after(grammarAccess.getCompareOpAccess().getGroup_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__CompareOp__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompareOp__Group_1_0_0__0__Impl
+ rule__CompareOp__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompareOp__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+(
+
+)
+{ after(grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CompareOp__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CompareOp__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompareOp__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompareOpAccess().getOperatorAssignment_1_0_0_1()); }
+(rule__CompareOp__OperatorAssignment_1_0_0_1)
+{ after(grammarAccess.getCompareOpAccess().getOperatorAssignment_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__RelationOp__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RelationOp__Group__0__Impl
+ rule__RelationOp__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationOp__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0()); }
+ ruleShiftOp
+{ after(grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RelationOp__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RelationOp__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationOp__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationOpAccess().getGroup_1()); }
+(rule__RelationOp__Group_1__0)*
+{ after(grammarAccess.getRelationOpAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__RelationOp__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RelationOp__Group_1__0__Impl
+ rule__RelationOp__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationOp__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationOpAccess().getGroup_1_0()); }
+(rule__RelationOp__Group_1_0__0)
+{ after(grammarAccess.getRelationOpAccess().getGroup_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RelationOp__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RelationOp__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationOp__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationOpAccess().getRightAssignment_1_1()); }
+(rule__RelationOp__RightAssignment_1_1)
+{ after(grammarAccess.getRelationOpAccess().getRightAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__RelationOp__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RelationOp__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationOp__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationOpAccess().getGroup_1_0_0()); }
+(rule__RelationOp__Group_1_0_0__0)
+{ after(grammarAccess.getRelationOpAccess().getGroup_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__RelationOp__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RelationOp__Group_1_0_0__0__Impl
+ rule__RelationOp__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationOp__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+(
+
+)
+{ after(grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RelationOp__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RelationOp__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationOp__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationOpAccess().getOperatorAssignment_1_0_0_1()); }
+(rule__RelationOp__OperatorAssignment_1_0_0_1)
+{ after(grammarAccess.getRelationOpAccess().getOperatorAssignment_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ShiftOp__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftOp__Group__0__Impl
+ rule__ShiftOp__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftOp__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0()); }
+ ruleAdditiveOp
+{ after(grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ShiftOp__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftOp__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftOp__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftOpAccess().getGroup_1()); }
+(rule__ShiftOp__Group_1__0)*
+{ after(grammarAccess.getShiftOpAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ShiftOp__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftOp__Group_1__0__Impl
+ rule__ShiftOp__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftOp__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftOpAccess().getGroup_1_0()); }
+(rule__ShiftOp__Group_1_0__0)
+{ after(grammarAccess.getShiftOpAccess().getGroup_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ShiftOp__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftOp__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftOp__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftOpAccess().getRightAssignment_1_1()); }
+(rule__ShiftOp__RightAssignment_1_1)
+{ after(grammarAccess.getShiftOpAccess().getRightAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ShiftOp__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftOp__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftOp__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftOpAccess().getGroup_1_0_0()); }
+(rule__ShiftOp__Group_1_0_0__0)
+{ after(grammarAccess.getShiftOpAccess().getGroup_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__ShiftOp__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftOp__Group_1_0_0__0__Impl
+ rule__ShiftOp__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftOp__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+(
+
+)
+{ after(grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ShiftOp__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ShiftOp__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftOp__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftOpAccess().getOperatorAssignment_1_0_0_1()); }
+(rule__ShiftOp__OperatorAssignment_1_0_0_1)
+{ after(grammarAccess.getShiftOpAccess().getOperatorAssignment_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AdditiveOp__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AdditiveOp__Group__0__Impl
+ rule__AdditiveOp__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0()); }
+ ruleMathOp
+{ after(grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AdditiveOp__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AdditiveOp__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getGroup_1()); }
+(rule__AdditiveOp__Group_1__0)*
+{ after(grammarAccess.getAdditiveOpAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AdditiveOp__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AdditiveOp__Group_1__0__Impl
+ rule__AdditiveOp__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getGroup_1_0()); }
+(rule__AdditiveOp__Group_1_0__0)
+{ after(grammarAccess.getAdditiveOpAccess().getGroup_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AdditiveOp__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AdditiveOp__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getRightAssignment_1_1()); }
+(rule__AdditiveOp__RightAssignment_1_1)
+{ after(grammarAccess.getAdditiveOpAccess().getRightAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AdditiveOp__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AdditiveOp__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getGroup_1_0_0()); }
+(rule__AdditiveOp__Group_1_0_0__0)
+{ after(grammarAccess.getAdditiveOpAccess().getGroup_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__AdditiveOp__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AdditiveOp__Group_1_0_0__0__Impl
+ rule__AdditiveOp__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+(
+
+)
+{ after(grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AdditiveOp__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AdditiveOp__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getOperatorAssignment_1_0_0_1()); }
+(rule__AdditiveOp__OperatorAssignment_1_0_0_1)
+{ after(grammarAccess.getAdditiveOpAccess().getOperatorAssignment_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__MathOp__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__MathOp__Group__0__Impl
+ rule__MathOp__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MathOp__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0()); }
+ ruleUnaryOp
+{ after(grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__MathOp__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__MathOp__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MathOp__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMathOpAccess().getGroup_1()); }
+(rule__MathOp__Group_1__0)*
+{ after(grammarAccess.getMathOpAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__MathOp__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__MathOp__Group_1__0__Impl
+ rule__MathOp__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MathOp__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMathOpAccess().getGroup_1_0()); }
+(rule__MathOp__Group_1_0__0)
+{ after(grammarAccess.getMathOpAccess().getGroup_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__MathOp__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__MathOp__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MathOp__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMathOpAccess().getRightAssignment_1_1()); }
+(rule__MathOp__RightAssignment_1_1)
+{ after(grammarAccess.getMathOpAccess().getRightAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__MathOp__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__MathOp__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MathOp__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMathOpAccess().getGroup_1_0_0()); }
+(rule__MathOp__Group_1_0_0__0)
+{ after(grammarAccess.getMathOpAccess().getGroup_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__MathOp__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__MathOp__Group_1_0_0__0__Impl
+ rule__MathOp__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MathOp__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+(
+
+)
+{ after(grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__MathOp__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__MathOp__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MathOp__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMathOpAccess().getOperatorAssignment_1_0_0_1()); }
+(rule__MathOp__OperatorAssignment_1_0_0_1)
+{ after(grammarAccess.getMathOpAccess().getOperatorAssignment_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__UnaryOp__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__UnaryOp__Group_0__0__Impl
+ rule__UnaryOp__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryOp__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryOpAccess().getAlternatives_0_0()); }
+(rule__UnaryOp__Alternatives_0_0)
+{ after(grammarAccess.getUnaryOpAccess().getAlternatives_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__UnaryOp__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__UnaryOp__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryOp__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1()); }
+ ruleExpression
+{ after(grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__UnaryOp__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__UnaryOp__Group_1__0__Impl
+ rule__UnaryOp__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryOp__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryOpAccess().getAlternatives_1_0()); }
+(rule__UnaryOp__Alternatives_1_0)
+{ after(grammarAccess.getUnaryOpAccess().getAlternatives_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__UnaryOp__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__UnaryOp__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryOp__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1()); }
+ ruleVariable
+{ after(grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__UnaryOp__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__UnaryOp__Group_2__0__Impl
+ rule__UnaryOp__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryOp__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0()); }
+ ruleApplication
+{ after(grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__UnaryOp__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__UnaryOp__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__UnaryOp__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getUnaryOpAccess().getQUESTIONTerminalRuleCall_2_1()); }
+( RULE_QUESTION)?
+{ after(grammarAccess.getUnaryOpAccess().getQUESTIONTerminalRuleCall_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Application__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Application__Group_0__0__Impl
+ rule__Application__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getSuperCallAction_0_0()); }
+(
+
+)
+{ after(grammarAccess.getApplicationAccess().getSuperCallAction_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Application__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Application__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getGroup_0_1()); }
+(rule__Application__Group_0_1__0)
+{ after(grammarAccess.getApplicationAccess().getGroup_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Application__Group_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Application__Group_0_1__0__Impl
+ rule__Application__Group_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Group_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0()); }
+ RULE_SUPER
+{ after(grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Application__Group_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Application__Group_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Group_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getGroup_0_1_1()); }
+(rule__Application__Group_0_1_1__0)?
+{ after(grammarAccess.getApplicationAccess().getGroup_0_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Application__Group_0_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Application__Group_0_1_1__0__Impl
+ rule__Application__Group_0_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Group_0_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0()); }
+ RULE_CALL_START
+{ after(grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Application__Group_0_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Application__Group_0_1_1__1__Impl
+ rule__Application__Group_0_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Group_0_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getArgsAssignment_0_1_1_1()); }
+(rule__Application__ArgsAssignment_0_1_1_1)
+{ after(grammarAccess.getApplicationAccess().getArgsAssignment_0_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Application__Group_0_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Application__Group_0_1_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Group_0_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2()); }
+ RULE_CALL_END
+{ after(grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Application__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Application__Group_1__0__Impl
+ rule__Application__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getValueAssignment_1_0()); }
+(rule__Application__ValueAssignment_1_0)
+{ after(grammarAccess.getApplicationAccess().getValueAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Application__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Application__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getFeaturesAssignment_1_1()); }
+(rule__Application__FeaturesAssignment_1_1)*
+{ after(grammarAccess.getApplicationAccess().getFeaturesAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__FunctionCall__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__FunctionCall__Group__0__Impl
+ rule__FunctionCall__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FunctionCall__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFunctionCallAccess().getFunctionCallAction_0()); }
+(
+
+)
+{ after(grammarAccess.getFunctionCallAccess().getFunctionCallAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__FunctionCall__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__FunctionCall__Group__1__Impl
+ rule__FunctionCall__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FunctionCall__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFunctionCallAccess().getFUNC_EXISTTerminalRuleCall_1()); }
+( RULE_FUNC_EXIST)?
+{ after(grammarAccess.getFunctionCallAccess().getFUNC_EXISTTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__FunctionCall__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__FunctionCall__Group__2__Impl
+ rule__FunctionCall__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FunctionCall__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2()); }
+ RULE_CALL_START
+{ after(grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__FunctionCall__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__FunctionCall__Group__3__Impl
+ rule__FunctionCall__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FunctionCall__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFunctionCallAccess().getArgsAssignment_3()); }
+(rule__FunctionCall__ArgsAssignment_3)
+{ after(grammarAccess.getFunctionCallAccess().getArgsAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__FunctionCall__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__FunctionCall__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FunctionCall__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4()); }
+ RULE_CALL_END
+{ after(grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__ThisProperty__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThisProperty__Group__0__Impl
+ rule__ThisProperty__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisProperty__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0()); }
+ RULE_AT_SIGIL
+{ after(grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ThisProperty__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ThisProperty__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThisProperty__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1()); }
+ ruleId
+{ after(grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__NamedPropertyAccess__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NamedPropertyAccess__Group_0__0__Impl
+ rule__NamedPropertyAccess__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_0_0()); }
+(rule__NamedPropertyAccess__AccessorAssignment_0_0)
+{ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NamedPropertyAccess__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NamedPropertyAccess__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_0_1()); }
+(rule__NamedPropertyAccess__NameAssignment_0_1)
+{ after(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__NamedPropertyAccess__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NamedPropertyAccess__Group_1__0__Impl
+ rule__NamedPropertyAccess__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_1_0()); }
+(rule__NamedPropertyAccess__AccessorAssignment_1_0)
+{ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NamedPropertyAccess__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NamedPropertyAccess__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_1_1()); }
+(rule__NamedPropertyAccess__NameAssignment_1_1)?
+{ after(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__IndexedPropertyAccess__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IndexedPropertyAccess__Group__0__Impl
+ rule__IndexedPropertyAccess__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IndexedPropertyAccess__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0()); }
+ RULE_INDEX_START
+{ after(grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IndexedPropertyAccess__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IndexedPropertyAccess__Group__1__Impl
+ rule__IndexedPropertyAccess__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IndexedPropertyAccess__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexedPropertyAccessAccess().getIndexAssignment_1()); }
+(rule__IndexedPropertyAccess__IndexAssignment_1)
+{ after(grammarAccess.getIndexedPropertyAccessAccess().getIndexAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IndexedPropertyAccess__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IndexedPropertyAccess__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IndexedPropertyAccess__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2()); }
+ RULE_INDEX_END
+{ after(grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Index__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Index__Group_0__0__Impl
+ rule__Index__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getDotsAssignment_0_0()); }
+(rule__Index__DotsAssignment_0_0)
+{ after(grammarAccess.getIndexAccess().getDotsAssignment_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Index__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Index__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getEndAssignment_0_1()); }
+(rule__Index__EndAssignment_0_1)
+{ after(grammarAccess.getIndexAccess().getEndAssignment_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Index__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Index__Group_1__0__Impl
+ rule__Index__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getGroup_1_0()); }
+(rule__Index__Group_1_0__0)
+{ after(grammarAccess.getIndexAccess().getGroup_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Index__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Index__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getEndAssignment_1_1()); }
+(rule__Index__EndAssignment_1_1)?
+{ after(grammarAccess.getIndexAccess().getEndAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Index__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Index__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getGroup_1_0_0()); }
+(rule__Index__Group_1_0_0__0)
+{ after(grammarAccess.getIndexAccess().getGroup_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__Index__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Index__Group_1_0_0__0__Impl
+ rule__Index__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getStartAssignment_1_0_0_0()); }
+(rule__Index__StartAssignment_1_0_0_0)
+{ after(grammarAccess.getIndexAccess().getStartAssignment_1_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Index__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Index__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getDotsAssignment_1_0_0_1()); }
+(rule__Index__DotsAssignment_1_0_0_1)
+{ after(grammarAccess.getIndexAccess().getDotsAssignment_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_8__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_8__0__Impl
+ rule__PrimaryExpression__Group_8__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_8__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0()); }
+(
+
+)
+{ after(grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_8__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_8__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_8__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1()); }
+ RULE_THIS
+{ after(grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_9__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_9__0__Impl
+ rule__PrimaryExpression__Group_9__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_9__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getForAction_9_0()); }
+(
+
+)
+{ after(grammarAccess.getPrimaryExpressionAccess().getForAction_9_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_9__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_9__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_9__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_9_1()); }
+(rule__PrimaryExpression__Group_9_1__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_9_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_9_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_9_1__0__Impl
+ rule__PrimaryExpression__Group_9_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_9_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0()); }
+ RULE_FOR
+{ after(grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_9_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_9_1__1__Impl
+ rule__PrimaryExpression__Group_9_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_9_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_9_1_1()); }
+(rule__PrimaryExpression__LoopAssignment_9_1_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_9_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_9_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_9_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_9_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_9_1_2()); }
+(rule__PrimaryExpression__BodyAssignment_9_1_2)
+{ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_9_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__PrimaryExpression__Group_10__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_10__0__Impl
+ rule__PrimaryExpression__Group_10__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_10__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0()); }
+(
+
+)
+{ after(grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_10__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_10__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_10__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1()); }
+(rule__PrimaryExpression__Group_10_1__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_10_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_10_1__0__Impl
+ rule__PrimaryExpression__Group_10_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_10_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0()); }
+ RULE_WHILE
+{ after(grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_10_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_10_1__1__Impl
+ rule__PrimaryExpression__Group_10_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_10_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_10_1_1()); }
+(rule__PrimaryExpression__LoopAssignment_10_1_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_10_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_10_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_10_1__2__Impl
+ rule__PrimaryExpression__Group_10_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_10_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1_2()); }
+(rule__PrimaryExpression__Group_10_1_2__0)?
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_10_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_10_1__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_10_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_10_1_3()); }
+(rule__PrimaryExpression__BodyAssignment_10_1_3)
+{ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_10_1_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__PrimaryExpression__Group_10_1_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_10_1_2__0__Impl
+ rule__PrimaryExpression__Group_10_1_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_10_1_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0()); }
+ RULE_WHEN
+{ after(grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_10_1_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_10_1_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_10_1_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_10_1_2_1()); }
+(rule__PrimaryExpression__WhenAssignment_10_1_2_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_10_1_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_11__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_11__0__Impl
+ rule__PrimaryExpression__Group_11__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_11__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0()); }
+(
+
+)
+{ after(grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_11__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_11__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_11__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1()); }
+(rule__PrimaryExpression__Group_11_1__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_11_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_11_1__0__Impl
+ rule__PrimaryExpression__Group_11_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_11_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0()); }
+ RULE_UNTIL
+{ after(grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_11_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_11_1__1__Impl
+ rule__PrimaryExpression__Group_11_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_11_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_11_1_1()); }
+(rule__PrimaryExpression__LoopAssignment_11_1_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_11_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_11_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_11_1__2__Impl
+ rule__PrimaryExpression__Group_11_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_11_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1_2()); }
+(rule__PrimaryExpression__Group_11_1_2__0)?
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_11_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_11_1__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_11_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_11_1_3()); }
+(rule__PrimaryExpression__BodyAssignment_11_1_3)
+{ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_11_1_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__PrimaryExpression__Group_11_1_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_11_1_2__0__Impl
+ rule__PrimaryExpression__Group_11_1_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_11_1_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0()); }
+ RULE_WHEN
+{ after(grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_11_1_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_11_1_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_11_1_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_11_1_2_1()); }
+(rule__PrimaryExpression__WhenAssignment_11_1_2_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_11_1_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_12__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_12__0__Impl
+ rule__PrimaryExpression__Group_12__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_12__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0()); }
+(
+
+)
+{ after(grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_12__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_12__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_12__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_12_1()); }
+(rule__PrimaryExpression__Group_12_1__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_12_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_12_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_12_1__0__Impl
+ rule__PrimaryExpression__Group_12_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_12_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0()); }
+ RULE_LOOP
+{ after(grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_12_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_12_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_12_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_12_1_1()); }
+(rule__PrimaryExpression__BodyAssignment_12_1_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_12_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_13__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13__0__Impl
+ rule__PrimaryExpression__Group_13__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0()); }
+(
+
+)
+{ after(grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_13__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1()); }
+(rule__PrimaryExpression__Group_13_1__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_13_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1__0__Impl
+ rule__PrimaryExpression__Group_13_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0()); }
+ RULE_TRY
+{ after(grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_13_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1__1__Impl
+ rule__PrimaryExpression__Group_13_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_13_1_1()); }
+(rule__PrimaryExpression__BodyAssignment_13_1_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_13_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_13_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getAlternatives_13_1_2()); }
+(rule__PrimaryExpression__Alternatives_13_1_2)?
+{ after(grammarAccess.getPrimaryExpressionAccess().getAlternatives_13_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__PrimaryExpression__Group_13_1_2_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1_2_0__0__Impl
+ rule__PrimaryExpression__Group_13_1_2_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1_2_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0()); }
+ RULE_CATCH
+{ after(grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_13_1_2_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1_2_0__1__Impl
+ rule__PrimaryExpression__Group_13_1_2_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1_2_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getExceptionAssignment_13_1_2_0_1()); }
+(rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getExceptionAssignment_13_1_2_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_13_1_2_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1_2_0__2__Impl
+ rule__PrimaryExpression__Group_13_1_2_0__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1_2_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getCatchBlockAssignment_13_1_2_0_2()); }
+(rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2)
+{ after(grammarAccess.getPrimaryExpressionAccess().getCatchBlockAssignment_13_1_2_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_13_1_2_0__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1_2_0__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1_2_0__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0_3()); }
+(rule__PrimaryExpression__Group_13_1_2_0_3__0)?
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__PrimaryExpression__Group_13_1_2_0_3__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl
+ rule__PrimaryExpression__Group_13_1_2_0_3__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0()); }
+ RULE_FINALLY
+{ after(grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_13_1_2_0_3__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_0_3_1()); }
+(rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_0_3_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_13_1_2_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1_2_1__0__Impl
+ rule__PrimaryExpression__Group_13_1_2_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1_2_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0()); }
+ RULE_FINALLY
+{ after(grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_13_1_2_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_13_1_2_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_13_1_2_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_1_1()); }
+(rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_14__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14__0__Impl
+ rule__PrimaryExpression__Group_14__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0()); }
+(
+
+)
+{ after(grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_14__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1()); }
+(rule__PrimaryExpression__Group_14_1__0)
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PrimaryExpression__Group_14_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14_1__0__Impl
+ rule__PrimaryExpression__Group_14_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0()); }
+ RULE_SWITCH
+{ after(grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_14_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14_1__1__Impl
+ rule__PrimaryExpression__Group_14_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getExpAssignment_14_1_1()); }
+(rule__PrimaryExpression__ExpAssignment_14_1_1)?
+{ after(grammarAccess.getPrimaryExpressionAccess().getExpAssignment_14_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_14_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14_1__2__Impl
+ rule__PrimaryExpression__Group_14_1__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2()); }
+ RULE_INDENT
+{ after(grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_14_1__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14_1__3__Impl
+ rule__PrimaryExpression__Group_14_1__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14_1__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_14_1_3()); }
+(rule__PrimaryExpression__CasesAssignment_14_1_3)*
+{ after(grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_14_1_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_14_1__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14_1__4__Impl
+ rule__PrimaryExpression__Group_14_1__5
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14_1__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1_4()); }
+(rule__PrimaryExpression__Group_14_1_4__0)?
+{ after(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_14_1__5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14_1__5__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14_1__5__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5()); }
+ RULE_OUTDENT
+{ after(grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__PrimaryExpression__Group_14_1_4__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14_1_4__0__Impl
+ rule__PrimaryExpression__Group_14_1_4__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14_1_4__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0()); }
+ RULE_ELSE
+{ after(grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__PrimaryExpression__Group_14_1_4__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__PrimaryExpression__Group_14_1_4__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__Group_14_1_4__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getElseBlockAssignment_14_1_4_1()); }
+(rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1)
+{ after(grammarAccess.getPrimaryExpressionAccess().getElseBlockAssignment_14_1_4_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Block__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Block__Group__0__Impl
+ rule__Block__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Block__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockAccess().getBlockAction_0()); }
+(
+
+)
+{ after(grammarAccess.getBlockAccess().getBlockAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Block__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Block__Group__1__Impl
+ rule__Block__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Block__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1()); }
+ RULE_INDENT
+{ after(grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Block__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Block__Group__2__Impl
+ rule__Block__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Block__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockAccess().getBodyParserRuleCall_2()); }
+( ruleBody)?
+{ after(grammarAccess.getBlockAccess().getBodyParserRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Block__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Block__Group__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Block__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3()); }
+ RULE_OUTDENT
+{ after(grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Case__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Case__Group__0__Impl
+ rule__Case__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0()); }
+ RULE_LEADING_WHEN
+{ after(grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Case__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Case__Group__1__Impl
+ rule__Case__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getWhensAssignment_1()); }
+(rule__Case__WhensAssignment_1)
+{ after(grammarAccess.getCaseAccess().getWhensAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Case__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Case__Group__2__Impl
+ rule__Case__Group__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getGroup_2()); }
+(rule__Case__Group_2__0)*
+{ after(grammarAccess.getCaseAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Case__Group__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Case__Group__3__Impl
+ rule__Case__Group__4
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__Group__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getThenAssignment_3()); }
+(rule__Case__ThenAssignment_3)
+{ after(grammarAccess.getCaseAccess().getThenAssignment_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Case__Group__4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Case__Group__4__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__Group__4__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getTERMINATORTerminalRuleCall_4()); }
+( RULE_TERMINATOR)?
+{ after(grammarAccess.getCaseAccess().getTERMINATORTerminalRuleCall_4()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__Case__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Case__Group_2__0__Impl
+ rule__Case__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0()); }
+ RULE_COMMA
+{ after(grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Case__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Case__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getWhensAssignment_2_1()); }
+(rule__Case__WhensAssignment_2_1)
+{ after(grammarAccess.getCaseAccess().getWhensAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__IfExp__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfExp__Group__0__Impl
+ rule__IfExp__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getBlocksAssignment_0()); }
+(rule__IfExp__BlocksAssignment_0)
+{ after(grammarAccess.getIfExpAccess().getBlocksAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IfExp__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfExp__Group__1__Impl
+ rule__IfExp__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getGroup_1()); }
+(rule__IfExp__Group_1__0)*
+{ after(grammarAccess.getIfExpAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IfExp__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfExp__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getGroup_2()); }
+(rule__IfExp__Group_2__0)?
+{ after(grammarAccess.getIfExpAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__IfExp__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfExp__Group_1__0__Impl
+ rule__IfExp__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0()); }
+ RULE_ELSE
+{ after(grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IfExp__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfExp__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getBlocksAssignment_1_1()); }
+(rule__IfExp__BlocksAssignment_1_1)
+{ after(grammarAccess.getIfExpAccess().getBlocksAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__IfExp__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfExp__Group_2__0__Impl
+ rule__IfExp__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0()); }
+ RULE_ELSE
+{ after(grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__IfExp__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__IfExp__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getDefaultBlockAssignment_2_1()); }
+(rule__IfExp__DefaultBlockAssignment_2_1)
+{ after(grammarAccess.getIfExpAccess().getDefaultBlockAssignment_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__CondBlock__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CondBlock__Group__0__Impl
+ rule__CondBlock__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CondBlock__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCondBlockAccess().getOperatorAssignment_0()); }
+(rule__CondBlock__OperatorAssignment_0)
+{ after(grammarAccess.getCondBlockAccess().getOperatorAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CondBlock__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CondBlock__Group__1__Impl
+ rule__CondBlock__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CondBlock__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCondBlockAccess().getConditionAssignment_1()); }
+(rule__CondBlock__ConditionAssignment_1)
+{ after(grammarAccess.getCondBlockAccess().getConditionAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__CondBlock__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__CondBlock__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CondBlock__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCondBlockAccess().getActionAssignment_2()); }
+(rule__CondBlock__ActionAssignment_2)
+{ after(grammarAccess.getCondBlockAccess().getActionAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Property__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_0__0__Impl
+ rule__Property__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getGroup_0_0()); }
+(rule__Property__Group_0_0__0)
+{ after(grammarAccess.getPropertyAccess().getGroup_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Property__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getPropAssignment_0_1()); }
+(rule__Property__PropAssignment_0_1)
+{ after(grammarAccess.getPropertyAccess().getPropAssignment_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Property__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_0_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getGroup_0_0_0()); }
+(rule__Property__Group_0_0_0__0)
+{ after(grammarAccess.getPropertyAccess().getGroup_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__Property__Group_0_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_0_0_0__0__Impl
+ rule__Property__Group_0_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_0_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0()); }
+ ruleIdRef
+{ after(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Property__Group_0_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_0_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_0_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getAccessorAssignment_0_0_0_1()); }
+(rule__Property__AccessorAssignment_0_0_0_1)
+{ after(grammarAccess.getPropertyAccess().getAccessorAssignment_0_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Property__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_1__0__Impl
+ rule__Property__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getGroup_1_0()); }
+(rule__Property__Group_1_0__0)
+{ after(grammarAccess.getPropertyAccess().getGroup_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Property__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_1__1__Impl
+ rule__Property__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getIndexAssignment_1_1()); }
+(rule__Property__IndexAssignment_1_1)
+{ after(grammarAccess.getPropertyAccess().getIndexAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Property__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2()); }
+ RULE_INDEX_END
+{ after(grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Property__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_1_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getGroup_1_0_0()); }
+(rule__Property__Group_1_0_0__0)
+{ after(grammarAccess.getPropertyAccess().getGroup_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__Property__Group_1_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_1_0_0__0__Impl
+ rule__Property__Group_1_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_1_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0()); }
+ ruleIdRef
+{ after(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Property__Group_1_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Property__Group_1_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__Group_1_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1()); }
+ RULE_INDEX_START
+{ after(grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Variable__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Variable__Group_1__0__Impl
+ rule__Variable__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getAlternatives_1_0()); }
+(rule__Variable__Alternatives_1_0)
+{ after(grammarAccess.getVariableAccess().getAlternatives_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Variable__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Variable__Group_1__1__Impl
+ rule__Variable__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getIdParserRuleCall_1_1()); }
+ ruleId
+{ after(grammarAccess.getVariableAccess().getIdParserRuleCall_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Variable__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Variable__Group_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getGroup_1_2()); }
+(rule__Variable__Group_1_2__0)*
+{ after(grammarAccess.getVariableAccess().getGroup_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Variable__Group_1_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Variable__Group_1_0_1__0__Impl
+ rule__Variable__Group_1_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__Group_1_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getTHISTerminalRuleCall_1_0_1_0()); }
+ RULE_THIS
+{ after(grammarAccess.getVariableAccess().getTHISTerminalRuleCall_1_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Variable__Group_1_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Variable__Group_1_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__Group_1_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_0_1_1()); }
+ RULE_DOT
+{ after(grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_0_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Variable__Group_1_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Variable__Group_1_2__0__Impl
+ rule__Variable__Group_1_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__Group_1_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0()); }
+ RULE_DOT
+{ after(grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Variable__Group_1_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Variable__Group_1_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__Group_1_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getPropsAssignment_1_2_1()); }
+(rule__Variable__PropsAssignment_1_2_1)
+{ after(grammarAccess.getVariableAccess().getPropsAssignment_1_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AssignableArray__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignableArray__Group__0__Impl
+ rule__AssignableArray__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArray__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0()); }
+( RULE_LBRACKET)
+{ after(grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignableArray__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignableArray__Group__1__Impl
+ rule__AssignableArray__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArray__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1()); }
+ ruleAssignableArgList
+{ after(grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignableArray__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignableArray__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArray__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2()); }
+ RULE_RBRACKET
+{ after(grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__AssignableArgList__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignableArgList__Group__0__Impl
+ rule__AssignableArgList__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArgList__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgListAccess().getArgsAssignment_0()); }
+(rule__AssignableArgList__ArgsAssignment_0)
+{ after(grammarAccess.getAssignableArgListAccess().getArgsAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignableArgList__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignableArgList__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArgList__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgListAccess().getGroup_1()); }
+(rule__AssignableArgList__Group_1__0)*
+{ after(grammarAccess.getAssignableArgListAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AssignableArgList__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignableArgList__Group_1__0__Impl
+ rule__AssignableArgList__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArgList__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0()); }
+ RULE_COMMA
+{ after(grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignableArgList__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignableArgList__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArgList__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgListAccess().getArgsAssignment_1_1()); }
+(rule__AssignableArgList__ArgsAssignment_1_1)
+{ after(grammarAccess.getAssignableArgListAccess().getArgsAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AssignableArg__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignableArg__Group__0__Impl
+ rule__AssignableArg__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArg__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgAccess().getArgAssignment_0()); }
+(rule__AssignableArg__ArgAssignment_0)
+{ after(grammarAccess.getAssignableArgAccess().getArgAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__AssignableArg__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__AssignableArg__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArg__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgAccess().getSplatAssignment_1()); }
+(rule__AssignableArg__SplatAssignment_1)?
+{ after(grammarAccess.getAssignableArgAccess().getSplatAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Arg__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Arg__Group__0__Impl
+ rule__Arg__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Arg__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgAccess().getExpAssignment_0()); }
+(rule__Arg__ExpAssignment_0)
+{ after(grammarAccess.getArgAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Arg__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Arg__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Arg__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgAccess().getSplatAssignment_1()); }
+(rule__Arg__SplatAssignment_1)?
+{ after(grammarAccess.getArgAccess().getSplatAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ArgLine__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgLine__Group__0__Impl
+ rule__ArgLine__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgLine__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgLineAccess().getHeadAssignment_0()); }
+(rule__ArgLine__HeadAssignment_0)
+{ after(grammarAccess.getArgLineAccess().getHeadAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ArgLine__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgLine__Group__1__Impl
+ rule__ArgLine__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgLine__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgLineAccess().getGroup_1()); }
+(rule__ArgLine__Group_1__0)*
+{ after(grammarAccess.getArgLineAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ArgLine__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgLine__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgLine__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_2()); }
+( RULE_COMMA)?
+{ after(grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ArgLine__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgLine__Group_1__0__Impl
+ rule__ArgLine__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgLine__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0()); }
+ RULE_COMMA
+{ after(grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ArgLine__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgLine__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgLine__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgLineAccess().getTailAssignment_1_1()); }
+(rule__ArgLine__TailAssignment_1_1)
+{ after(grammarAccess.getArgLineAccess().getTailAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ExplicitArgList__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitArgList__Group__0__Impl
+ rule__ExplicitArgList__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getLinesAssignment_0()); }
+(rule__ExplicitArgList__LinesAssignment_0)
+{ after(grammarAccess.getExplicitArgListAccess().getLinesAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExplicitArgList__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitArgList__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getAlternatives_1()); }
+(rule__ExplicitArgList__Alternatives_1)*
+{ after(grammarAccess.getExplicitArgListAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ExplicitArgList__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitArgList__Group_1_0__0__Impl
+ rule__ExplicitArgList__Group_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0()); }
+ RULE_TERMINATOR
+{ after(grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExplicitArgList__Group_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitArgList__Group_1_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__Group_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_0_1()); }
+(rule__ExplicitArgList__LinesAssignment_1_0_1)
+{ after(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ExplicitArgList__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitArgList__Group_1_1__0__Impl
+ rule__ExplicitArgList__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0()); }
+ RULE_INDENT
+{ after(grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExplicitArgList__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitArgList__Group_1_1__1__Impl
+ rule__ExplicitArgList__Group_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_1_1()); }
+(rule__ExplicitArgList__LinesAssignment_1_1_1)
+{ after(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExplicitArgList__Group_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitArgList__Group_1_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__Group_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2()); }
+ RULE_OUTDENT
+{ after(grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ArgList__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgList__Group__0__Impl
+ rule__ArgList__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgList__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgListAccess().getArgListAction_0()); }
+(
+
+)
+{ after(grammarAccess.getArgListAccess().getArgListAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ArgList__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgList__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgList__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgListAccess().getAlternatives_1()); }
+(rule__ArgList__Alternatives_1)?
+{ after(grammarAccess.getArgListAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ArgList__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgList__Group_1_1__0__Impl
+ rule__ArgList__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgList__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0()); }
+ RULE_INDENT
+{ after(grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ArgList__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgList__Group_1_1__1__Impl
+ rule__ArgList__Group_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgList__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgListAccess().getDummyAssignment_1_1_1()); }
+(rule__ArgList__DummyAssignment_1_1_1)
+{ after(grammarAccess.getArgListAccess().getDummyAssignment_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ArgList__Group_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ArgList__Group_1_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgList__Group_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2()); }
+ RULE_OUTDENT
+{ after(grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Array__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Array__Group__0__Impl
+ rule__Array__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Array__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0()); }
+( RULE_LBRACKET)
+{ after(grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Array__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Array__Group__1__Impl
+ rule__Array__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Array__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArrayAccess().getArgListParserRuleCall_1()); }
+ ruleArgList
+{ after(grammarAccess.getArrayAccess().getArgListParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Array__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Array__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Array__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2()); }
+ RULE_RBRACKET
+{ after(grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Dictionary__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Dictionary__Group__0__Impl
+ rule__Dictionary__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Dictionary__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0()); }
+( RULE_LCURLY)
+{ after(grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Dictionary__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Dictionary__Group__1__Impl
+ rule__Dictionary__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Dictionary__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1()); }
+ ruleDictItems
+{ after(grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Dictionary__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Dictionary__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Dictionary__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2()); }
+ RULE_RCURLY
+{ after(grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__DictItems__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItems__Group__0__Impl
+ rule__DictItems__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItems__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemsAccess().getDictItemsAction_0()); }
+(
+
+)
+{ after(grammarAccess.getDictItemsAccess().getDictItemsAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictItems__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItems__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItems__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemsAccess().getAlternatives_1()); }
+(rule__DictItems__Alternatives_1)?
+{ after(grammarAccess.getDictItemsAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__DictItems__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItems__Group_1_1__0__Impl
+ rule__DictItems__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItems__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0()); }
+ RULE_INDENT
+{ after(grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictItems__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItems__Group_1_1__1__Impl
+ rule__DictItems__Group_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItems__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemsAccess().getDummyAssignment_1_1_1()); }
+(rule__DictItems__DummyAssignment_1_1_1)
+{ after(grammarAccess.getDictItemsAccess().getDummyAssignment_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictItems__Group_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItems__Group_1_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItems__Group_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2()); }
+ RULE_OUTDENT
+{ after(grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ExplicitDictItems__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitDictItems__Group__0__Impl
+ rule__ExplicitDictItems__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_0()); }
+(rule__ExplicitDictItems__LinesAssignment_0)
+{ after(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExplicitDictItems__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitDictItems__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getAlternatives_1()); }
+(rule__ExplicitDictItems__Alternatives_1)*
+{ after(grammarAccess.getExplicitDictItemsAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ExplicitDictItems__Group_1_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitDictItems__Group_1_0__0__Impl
+ rule__ExplicitDictItems__Group_1_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__Group_1_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0()); }
+ RULE_TERMINATOR
+{ after(grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExplicitDictItems__Group_1_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitDictItems__Group_1_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__Group_1_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_0_1()); }
+(rule__ExplicitDictItems__LinesAssignment_1_0_1)
+{ after(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ExplicitDictItems__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitDictItems__Group_1_1__0__Impl
+ rule__ExplicitDictItems__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0()); }
+ RULE_INDENT
+{ after(grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExplicitDictItems__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitDictItems__Group_1_1__1__Impl
+ rule__ExplicitDictItems__Group_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_1_1()); }
+(rule__ExplicitDictItems__LinesAssignment_1_1_1)
+{ after(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__ExplicitDictItems__Group_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__ExplicitDictItems__Group_1_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__Group_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2()); }
+ RULE_OUTDENT
+{ after(grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__DictLine__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictLine__Group__0__Impl
+ rule__DictLine__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictLine__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictLineAccess().getHeadAssignment_0()); }
+(rule__DictLine__HeadAssignment_0)
+{ after(grammarAccess.getDictLineAccess().getHeadAssignment_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictLine__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictLine__Group__1__Impl
+ rule__DictLine__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictLine__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictLineAccess().getGroup_1()); }
+(rule__DictLine__Group_1__0)*
+{ after(grammarAccess.getDictLineAccess().getGroup_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictLine__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictLine__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictLine__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_2()); }
+( RULE_COMMA)?
+{ after(grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__DictLine__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictLine__Group_1__0__Impl
+ rule__DictLine__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictLine__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0()); }
+ RULE_COMMA
+{ after(grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictLine__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictLine__Group_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictLine__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictLineAccess().getTailAssignment_1_1()); }
+(rule__DictLine__TailAssignment_1_1)
+{ after(grammarAccess.getDictLineAccess().getTailAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__DictItem__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItem__Group__0__Impl
+ rule__DictItem__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getDictItemAction_0()); }
+(
+
+)
+{ after(grammarAccess.getDictItemAccess().getDictItemAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictItem__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItem__Group__1__Impl
+ rule__DictItem__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getKeyAssignment_1()); }
+(rule__DictItem__KeyAssignment_1)
+{ after(grammarAccess.getDictItemAccess().getKeyAssignment_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictItem__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItem__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getGroup_2()); }
+(rule__DictItem__Group_2__0)?
+{ after(grammarAccess.getDictItemAccess().getGroup_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__DictItem__Group_2__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItem__Group_2__0__Impl
+ rule__DictItem__Group_2__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__Group_2__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0()); }
+ RULE_COLON
+{ after(grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictItem__Group_2__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItem__Group_2__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__Group_2__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getAlternatives_2_1()); }
+(rule__DictItem__Alternatives_2_1)
+{ after(grammarAccess.getDictItemAccess().getAlternatives_2_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__DictItem__Group_2_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItem__Group_2_1_1__0__Impl
+ rule__DictItem__Group_2_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__Group_2_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0()); }
+ RULE_INDENT
+{ after(grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictItem__Group_2_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItem__Group_2_1_1__1__Impl
+ rule__DictItem__Group_2_1_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__Group_2_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getValueAssignment_2_1_1_1()); }
+(rule__DictItem__ValueAssignment_2_1_1_1)
+{ after(grammarAccess.getDictItemAccess().getValueAssignment_2_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__DictItem__Group_2_1_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__DictItem__Group_2_1_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__Group_2_1_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2()); }
+ RULE_OUTDENT
+{ after(grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Lambda__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group__0__Impl
+ rule__Lambda__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getGroup_0()); }
+(rule__Lambda__Group_0__0)?
+{ after(grammarAccess.getLambdaAccess().getGroup_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Lambda__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group__1__Impl
+ rule__Lambda__Group__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getAlternatives_1()); }
+(rule__Lambda__Alternatives_1)
+{ after(grammarAccess.getLambdaAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Lambda__Group__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getBodyAssignment_2()); }
+(rule__Lambda__BodyAssignment_2)
+{ after(grammarAccess.getLambdaAccess().getBodyAssignment_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Lambda__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group_0__0__Impl
+ rule__Lambda__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0()); }
+ RULE_PARAM_START
+{ after(grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Lambda__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group_0__1__Impl
+ rule__Lambda__Group_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getGroup_0_1()); }
+(rule__Lambda__Group_0_1__0)?
+{ after(grammarAccess.getLambdaAccess().getGroup_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Lambda__Group_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group_0__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2()); }
+ RULE_PARAM_END
+{ after(grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Lambda__Group_0_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group_0_1__0__Impl
+ rule__Lambda__Group_0_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group_0_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_0()); }
+(rule__Lambda__ParamsAssignment_0_1_0)
+{ after(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Lambda__Group_0_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group_0_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group_0_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getGroup_0_1_1()); }
+(rule__Lambda__Group_0_1_1__0)*
+{ after(grammarAccess.getLambdaAccess().getGroup_0_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Lambda__Group_0_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group_0_1_1__0__Impl
+ rule__Lambda__Group_0_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group_0_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0()); }
+ RULE_COMMA
+{ after(grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Lambda__Group_0_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Lambda__Group_0_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__Group_0_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_1_1()); }
+(rule__Lambda__ParamsAssignment_0_1_1_1)
+{ after(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Param__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Param__Group__0__Impl
+ rule__Param__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Param__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParamAccess().getAlternatives_0()); }
+(rule__Param__Alternatives_0)
+{ after(grammarAccess.getParamAccess().getAlternatives_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Param__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Param__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Param__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParamAccess().getAlternatives_1()); }
+(rule__Param__Alternatives_1)?
+{ after(grammarAccess.getParamAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Param__Group_1_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Param__Group_1_1__0__Impl
+ rule__Param__Group_1_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Param__Group_1_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0()); }
+ RULE_EQUAL
+{ after(grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Param__Group_1_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Param__Group_1_1__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Param__Group_1_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParamAccess().getDefaultValueAssignment_1_1_1()); }
+(rule__Param__DefaultValueAssignment_1_1_1)
+{ after(grammarAccess.getParamAccess().getDefaultValueAssignment_1_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__NumberLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NumberLiteral__Group__0__Impl
+ rule__NumberLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NumberLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0()); }
+(
+
+)
+{ after(grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__NumberLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__NumberLiteral__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NumberLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1()); }
+ RULE_NUMBER
+{ after(grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__StringLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__StringLiteral__Group__0__Impl
+ rule__StringLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__StringLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0()); }
+(
+
+)
+{ after(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__StringLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__StringLiteral__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__StringLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1()); }
+ RULE_STRING
+{ after(grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__BoolLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__BoolLiteral__Group__0__Impl
+ rule__BoolLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__BoolLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0()); }
+(
+
+)
+{ after(grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__BoolLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__BoolLiteral__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__BoolLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1()); }
+ RULE_BOOL
+{ after(grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__JSLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JSLiteral__Group__0__Impl
+ rule__JSLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JSLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getJSLiteralAccess().getJSLiteralAction_0()); }
+(
+
+)
+{ after(grammarAccess.getJSLiteralAccess().getJSLiteralAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__JSLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__JSLiteral__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__JSLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1()); }
+ RULE_JS
+{ after(grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__RegexLiteral__Group__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RegexLiteral__Group__0__Impl
+ rule__RegexLiteral__Group__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RegexLiteral__Group__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0()); }
+(
+
+)
+{ after(grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__RegexLiteral__Group__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__RegexLiteral__Group__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RegexLiteral__Group__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1()); }
+ RULE_REGEX
+{ after(grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Parenthetical__Group_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_0__0__Impl
+ rule__Parenthetical__Group_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getGroup_0_0()); }
+(rule__Parenthetical__Group_0_0__0)
+{ after(grammarAccess.getParentheticalAccess().getGroup_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Parenthetical__Group_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_0__1__Impl
+ rule__Parenthetical__Group_0__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getContentAssignment_0_1()); }
+(rule__Parenthetical__ContentAssignment_0_1)
+{ after(grammarAccess.getParentheticalAccess().getContentAssignment_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Parenthetical__Group_0__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_0__2__Impl
+ rule__Parenthetical__Group_0__3
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_0__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2()); }
+ RULE_OUTDENT
+{ after(grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Parenthetical__Group_0__3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_0__3__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_0__3__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3()); }
+ RULE_RPAREN
+{ after(grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Parenthetical__Group_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_0_0__0__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getGroup_0_0_0()); }
+(rule__Parenthetical__Group_0_0_0__0)
+{ after(grammarAccess.getParentheticalAccess().getGroup_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+rule__Parenthetical__Group_0_0_0__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_0_0_0__0__Impl
+ rule__Parenthetical__Group_0_0_0__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_0_0_0__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0()); }
+ RULE_LPAREN
+{ after(grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Parenthetical__Group_0_0_0__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_0_0_0__1__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_0_0_0__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1()); }
+ RULE_INDENT
+{ after(grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Parenthetical__Group_1__0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_1__0__Impl
+ rule__Parenthetical__Group_1__1
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_1__0__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0()); }
+( RULE_LPAREN)
+{ after(grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Parenthetical__Group_1__1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_1__1__Impl
+ rule__Parenthetical__Group_1__2
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_1__1__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getContentAssignment_1_1()); }
+(rule__Parenthetical__ContentAssignment_1_1)
+{ after(grammarAccess.getParentheticalAccess().getContentAssignment_1_1()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+rule__Parenthetical__Group_1__2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+ rule__Parenthetical__Group_1__2__Impl
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__Group_1__2__Impl
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2()); }
+ RULE_RPAREN
+{ after(grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+rule__Cakefile__TasksAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCakefileAccess().getTasksTaskDeclarationParserRuleCall_0()); }
+ ruleTaskDeclaration{ after(grammarAccess.getCakefileAccess().getTasksTaskDeclarationParserRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__NameAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getNameStringLiteralParserRuleCall_2_0()); }
+ ruleStringLiteral{ after(grammarAccess.getTaskDeclarationAccess().getNameStringLiteralParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__DescriptionAssignment_4
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getDescriptionStringLiteralParserRuleCall_4_0()); }
+ ruleStringLiteral{ after(grammarAccess.getTaskDeclarationAccess().getDescriptionStringLiteralParserRuleCall_4_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__OptionsAssignment_6_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getOptionsIdParserRuleCall_6_1_0()); }
+ ruleId{ after(grammarAccess.getTaskDeclarationAccess().getOptionsIdParserRuleCall_6_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__TaskDeclaration__BodyAssignment_8
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getTaskDeclarationAccess().getBodyBlockParserRuleCall_8_0()); }
+ ruleBlock{ after(grammarAccess.getTaskDeclarationAccess().getBodyBlockParserRuleCall_8_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Body__LinesAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0()); }
+ ruleLine{ after(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Body__LinesAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0()); }
+ ruleLine{ after(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Stmt__StatementAssignment_5
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0()); }
+ RULE_STATEMENT{ after(grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Comment__CommentAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0()); }
+ RULE_HERECOMMENT{ after(grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__ImportedNamespaceAssignment_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0()); }
+ ruleId{ after(grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RequireStmt__UriAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0()); }
+ RULE_STRING{ after(grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStmt__ExpressionAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0()); }
+ ruleExpression{ after(grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ReturnStmt__ConditionAssignment_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0()); }
+ ruleExpression{ after(grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ThrowStmt__ExpAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0()); }
+ ruleExpression{ after(grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__BodyAssignment_2_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0()); }
+ ruleBlock{ after(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__ExtendAssignment_2_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0()); }
+ ruleSuperClass{ after(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__BodyAssignment_2_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0()); }
+ ruleBlock{ after(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__NameAssignment_2_2_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getNameAlternatives_2_2_0_0()); }
+(rule__ClassDeclaration__NameAlternatives_2_2_0_0)
+{ after(grammarAccess.getClassDeclarationAccess().getNameAlternatives_2_2_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__ExtendAssignment_2_2_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0()); }
+ ruleSuperClass{ after(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ClassDeclaration__BodyAssignment_2_2_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0()); }
+ ruleBlock{ after(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__ExtendAssignment_2_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0()); }
+ ruleSuperClass{ after(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__BodyAssignment_2_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0()); }
+ ruleBlock{ after(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__NameAssignment_2_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getNameAlternatives_2_1_0_0()); }
+(rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0)
+{ after(grammarAccess.getAssignedClassDeclarationAccess().getNameAlternatives_2_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0()); }
+ ruleSuperClass{ after(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignedClassDeclaration__BodyAssignment_2_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0()); }
+ ruleBlock{ after(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__ConditionAssignment_1_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0()); }
+ ruleExpression{ after(grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__BodyAssignment_1_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0()); }
+ ruleForBody{ after(grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__BodyAssignment_1_2_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0()); }
+ ruleExpression{ after(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__WhenAssignment_1_2_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0()); }
+ ruleExpression{ after(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__BodyAssignment_1_3_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0()); }
+ ruleExpression{ after(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Postfix__WhenAssignment_1_3_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0()); }
+ ruleExpression{ after(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForBody__IndexesAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0()); }
+ ruleForValue{ after(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForBody__IndexesAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0()); }
+ ruleForValue{ after(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForBody__SourceAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0()); }
+ ruleForSource{ after(grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__SourceAssignment_1_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0()); }
+ ruleExpression{ after(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__WhenAssignment_1_0_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0()); }
+ ruleExpression{ after(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__SourceAssignment_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__WhenAssignment_1_1_2_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0()); }
+ ruleExpression{ after(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__ByAssignment_1_1_2_0_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0()); }
+ ruleExpression{ after(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__ByAssignment_1_1_2_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ForSource__WhenAssignment_1_1_2_1_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0()); }
+ ruleExpression{ after(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__StartAssignment_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0()); }
+ ruleExpression{ after(grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Range__EndAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0()); }
+ ruleExpression{ after(grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__LeftAssignment_0_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0()); }
+ ruleAssignable{ after(grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__OperatorAssignment_0_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getOperatorAlternatives_0_0_0_1_0()); }
+(rule__Assignment__OperatorAlternatives_0_0_0_1_0)
+{ after(grammarAccess.getAssignmentAccess().getOperatorAlternatives_0_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Assignment__RightAssignment_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0()); }
+ ruleAssigned{ after(grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LogicOp__OperatorAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0()); }
+ RULE_LOGIC{ after(grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__LogicOp__RightAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0()); }
+ ruleCompareOp{ after(grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompareOp__OperatorAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0()); }
+ RULE_COMPARE{ after(grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CompareOp__RightAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0()); }
+ ruleRelationOp{ after(grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationOp__OperatorAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0()); }
+ RULE_RELATION{ after(grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__RelationOp__RightAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0()); }
+ ruleShiftOp{ after(grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftOp__OperatorAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0()); }
+ RULE_SHIFT{ after(grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ShiftOp__RightAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0()); }
+ ruleAdditiveOp{ after(grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__OperatorAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getOperatorAlternatives_1_0_0_1_0()); }
+(rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0)
+{ after(grammarAccess.getAdditiveOpAccess().getOperatorAlternatives_1_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AdditiveOp__RightAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0()); }
+ ruleMathOp{ after(grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MathOp__OperatorAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0()); }
+ RULE_MATH{ after(grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__MathOp__RightAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0()); }
+ ruleUnaryOp{ after(grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__ArgsAssignment_0_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0()); }
+ ruleArgList{ after(grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__ValueAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0()); }
+ rulePrimaryExpression{ after(grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Application__FeaturesAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0()); }
+ ruleFeatureCall{ after(grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__FunctionCall__ArgsAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0()); }
+ ruleArgList{ after(grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__AccessorAssignment_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorAlternatives_0_0_0()); }
+(rule__NamedPropertyAccess__AccessorAlternatives_0_0_0)
+{ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorAlternatives_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__NameAssignment_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0()); }
+ ruleId{ after(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__AccessorAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0()); }
+ RULE_DOUBLE_COLON{ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__NamedPropertyAccess__NameAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0()); }
+ ruleId{ after(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IndexedPropertyAccess__IndexAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0()); }
+ ruleIndex{ after(grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__DotsAssignment_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getDotsAlternatives_0_0_0()); }
+(rule__Index__DotsAlternatives_0_0_0)
+{ after(grammarAccess.getIndexAccess().getDotsAlternatives_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__EndAssignment_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0()); }
+ ruleExpression{ after(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__StartAssignment_1_0_0_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0()); }
+ ruleExpression{ after(grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__DotsAssignment_1_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getDotsAlternatives_1_0_0_1_0()); }
+(rule__Index__DotsAlternatives_1_0_0_1_0)
+{ after(grammarAccess.getIndexAccess().getDotsAlternatives_1_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__EndAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Index__ExpAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0()); }
+ ruleExpression{ after(grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__LoopAssignment_9_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0()); }
+ ruleForBody{ after(grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__BodyAssignment_9_1_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0()); }
+ ruleBlock{ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__LoopAssignment_10_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__WhenAssignment_10_1_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0()); }
+ ruleExpression{ after(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__BodyAssignment_10_1_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0()); }
+ ruleBlock{ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__LoopAssignment_11_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__WhenAssignment_11_1_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0()); }
+ ruleExpression{ after(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__BodyAssignment_11_1_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0()); }
+ ruleBlock{ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__BodyAssignment_12_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0()); }
+ ruleBlock{ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__BodyAssignment_13_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0()); }
+ ruleBlock{ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0()); }
+ ruleId{ after(grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0()); }
+ ruleBlock{ after(grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0()); }
+ ruleBlock{ after(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0()); }
+ ruleBlock{ after(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__ExpAssignment_14_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__CasesAssignment_14_1_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0()); }
+ ruleCase{ after(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0()); }
+ ruleBlock{ after(grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__WhensAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0()); }
+ ruleExpression{ after(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__WhensAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0()); }
+ ruleExpression{ after(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Case__ThenAssignment_3
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0()); }
+ ruleBlock{ after(grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__BlocksAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0()); }
+ ruleCondBlock{ after(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__BlocksAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0()); }
+ ruleCondBlock{ after(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IfExp__DefaultBlockAssignment_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0()); }
+ ruleBlock{ after(grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CondBlock__OperatorAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0()); }
+ RULE_IF{ after(grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CondBlock__ConditionAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0()); }
+ ruleExpression{ after(grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__CondBlock__ActionAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0()); }
+ ruleBlock{ after(grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__IdRef__ValAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIdRefAccess().getValIdCrossReference_0()); }
+(
+{ before(grammarAccess.getIdRefAccess().getValIdIDENTIFIERTerminalRuleCall_0_1()); }
+ RULE_IDENTIFIER{ after(grammarAccess.getIdRefAccess().getValIdIDENTIFIERTerminalRuleCall_0_1()); }
+)
+{ after(grammarAccess.getIdRefAccess().getValIdCrossReference_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Id__NameAssignment
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0()); }
+ RULE_IDENTIFIER{ after(grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__AccessorAssignment_0_0_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getAccessorAlternatives_0_0_0_1_0()); }
+(rule__Property__AccessorAlternatives_0_0_0_1_0)
+{ after(grammarAccess.getPropertyAccess().getAccessorAlternatives_0_0_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__PropAssignment_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0()); }
+ ruleId{ after(grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Property__IndexAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0()); }
+ ruleIndex{ after(grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Variable__PropsAssignment_1_2_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0()); }
+ ruleId{ after(grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArgList__ArgsAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0()); }
+ ruleAssignableArg{ after(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArgList__ArgsAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0()); }
+ ruleAssignableArg{ after(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArg__ArgAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0()); }
+ ruleAssignable{ after(grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__AssignableArg__SplatAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0()); }
+ RULE_ELLIPSIS{ after(grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Arg__ExpAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0()); }
+ ruleExpression{ after(grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Arg__SplatAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0()); }
+ RULE_ELLIPSIS{ after(grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgLine__HeadAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0()); }
+ ruleArg{ after(grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgLine__TailAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0()); }
+ ruleArg{ after(grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__LinesAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0()); }
+ ruleArgLine{ after(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__LinesAssignment_1_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0()); }
+ ruleArgLine{ after(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitArgList__LinesAssignment_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0()); }
+ ruleArgLine{ after(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgList__DummyAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0()); }
+ ruleExplicitArgList{ after(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ArgList__DummyAssignment_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0()); }
+ ruleExplicitArgList{ after(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItems__DummyAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0()); }
+ ruleExplicitDictItems{ after(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItems__DummyAssignment_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0()); }
+ ruleExplicitDictItems{ after(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__LinesAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0()); }
+ ruleDictLine{ after(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__LinesAssignment_1_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0()); }
+ ruleDictLine{ after(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__ExplicitDictItems__LinesAssignment_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0()); }
+ ruleDictLine{ after(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictLine__HeadAssignment_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0()); }
+ ruleDictItem{ after(grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictLine__TailAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0()); }
+ ruleDictItem{ after(grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__KeyAssignment_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0()); }
+ ruleDictKey{ after(grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__ValueAssignment_2_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0()); }
+ ruleExpression{ after(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__DictItem__ValueAssignment_2_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__ParamsAssignment_0_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0()); }
+ ruleParam{ after(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__ParamsAssignment_0_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0()); }
+ ruleParam{ after(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Lambda__BodyAssignment_2
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0()); }
+ ruleBlock{ after(grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Param__SplatAssignment_1_0
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0()); }
+ RULE_ELLIPSIS{ after(grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Param__DefaultValueAssignment_1_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0()); }
+ ruleExpression{ after(grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__ContentAssignment_0_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0()); }
+ ruleBody{ after(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+rule__Parenthetical__ContentAssignment_1_1
+ @init {
+ int stackSize = keepStackSize();
+ }
+:
+(
+{ before(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0()); }
+ ruleBody{ after(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+ restoreStackSize(stackSize);
+}
+
+
+RULE_TASK : 'task';
+
+RULE_ELLIPSIS : '...';
+
+RULE_DOT_DOT : '..';
+
+RULE_DOUBLE_COLON : '::';
+
+RULE_SHIFT : ('<<'|'>>');
+
+RULE_BOUND_FUNC_ARROW : '=>';
+
+RULE_FUNC_ARROW : '->';
+
+RULE_COMPARE : ('<'|'=='|'>'|'<='|'>='|'!=');
+
+RULE_COMPOUND_ASSIGN : ('+='|'-=');
+
+RULE_PLUS_PLUS : '++';
+
+RULE_MINUS_MINUS : '--';
+
+RULE_PARAM_END : '**)';
+
+RULE_PARAM_START : '(**';
+
+RULE_AT_SIGIL : '@';
+
+RULE_BOOL : ('true'|'false'|'undefined'|'null'|'on'|'no'|'yes'|'off');
+
+RULE_BY : 'by';
+
+RULE_CALL_END : '*)';
+
+RULE_CALL_START : '(*';
+
+RULE_CATCH : 'catch';
+
+RULE_CLASS : 'class';
+
+RULE_COLON : ':';
+
+RULE_COLON_SLASH : 'dummy COLON_SLASH';
+
+RULE_COMMA : ',';
+
+RULE_DOT : '.';
+
+RULE_ELSE : 'else';
+
+RULE_EQUAL : '=';
+
+RULE_EXTENDS : 'extends';
+
+RULE_FINALLY : 'finally';
+
+RULE_FOR : 'for';
+
+RULE_FORIN : 'in';
+
+RULE_FOROF : 'of';
+
+RULE_FUNC_EXIST : 'dummy FUNC_EXIST';
+
+RULE_HERECOMMENT : 'dummy HERECOMMENT';
+
+RULE_IF : ('if'|'unless');
+
+RULE_INDENT : '{*';
+
+RULE_INDEX_END : '*]';
+
+RULE_INDEX_PROTO : 'dummy INDEX_PROTO';
+
+RULE_INDEX_SOAK : 'dummy INDEX_SOAK';
+
+RULE_INDEX_START : '[*';
+
+RULE_JS : 'dummy JS';
+
+RULE_LBRACKET : '[';
+
+RULE_LCURLY : 'dummy LCURLY';
+
+RULE_LEADING_WHEN : 'dummy LEADING_WHEN';
+
+RULE_LOGIC : ('&&'|'||');
+
+RULE_LOOP : 'loop';
+
+RULE_LPAREN : '(';
+
+RULE_MATH : ('*'|'/');
+
+RULE_MINUS : '-';
+
+RULE_NEW : 'new';
+
+RULE_NUMBER : ('0'..'9')+;
+
+RULE_OUTDENT : '*}';
+
+RULE_OWN : 'own';
+
+RULE_PLUS : '+';
+
+RULE_POST_IF : 'dummy POST_IF';
+
+RULE_QUESTION : '?';
+
+RULE_QUESTION_DOT : '?.';
+
+RULE_RBRACKET : ']';
+
+RULE_RCURLY : 'dummy RCURLY';
+
+RULE_REGEX : '///' ( options {greedy=false;} : . )*'///';
+
+RULE_RELATION : ('in'|'of'|'instanceof');
+
+RULE_RETURN : 'return';
+
+RULE_RPAREN : ')';
+
+RULE_STATEMENT : ('break'|'continue'|'debugger');
+
+RULE_STRING : ('\'\'\'' ( options {greedy=false;} : . )*'\'\'\''|'\'' (~('\'') ('\\' ('b'|'t'|'n'|'f'|'r'|'u'|'"'|'\''|'\\')|~(('\\'|'\'')))*)? '\''|'"""' ( options {greedy=false;} : . )*'"""'|'"' (~('"') ('\\' ('b'|'t'|'n'|'f'|'r'|'u'|'"'|'\''|'\\')|~(('\\'|'"')))*)? '"');
+
+RULE_SUPER : 'super';
+
+RULE_SWITCH : 'switch';
+
+RULE_TERMINATOR : '\n'+;
+
+RULE_THEN : 'then';
+
+RULE_THIS : 'this';
+
+RULE_THROW : 'throw';
+
+RULE_TRY : 'try';
+
+RULE_UNARY : ('!'|'~');
+
+RULE_UNTIL : 'until';
+
+RULE_WHEN : 'when';
+
+RULE_WHILE : 'while';
+
+RULE_LOGIC_WORD : ('and'|'or');
+
+RULE_COMPARE_WORD : ('isnt'|'is');
+
+RULE_UNARY_WORD : ('new'|'do'|'not');
+
+RULE_ML_COMMENT : '###' ~('#') ( options {greedy=false;} : . )*'###';
+
+RULE_SL_COMMENT : '#' ~(('\n'|'\r'))* ('\r'? '\n')?;
+
+RULE_WS : (' '|'\t')+;
+
+RULE_IDENTIFIER : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
+
+
diff --git a/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.tokens b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.tokens
new file mode 100644
index 0000000..a4105ea
--- /dev/null
+++ b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.tokens
@@ -0,0 +1,84 @@
+RULE_BOUND_FUNC_ARROW=18
+RULE_SWITCH=53
+RULE_THROW=28
+RULE_PARAM_START=24
+RULE_TERMINATOR=23
+RULE_CALL_END=22
+RULE_RETURN=26
+RULE_FOR=31
+RULE_BOOL=61
+RULE_LBRACKET=40
+RULE_DOUBLE_COLON=15
+RULE_MINUS_MINUS=12
+RULE_COMPARE_WORD=81
+RULE_OUTDENT=42
+RULE_RELATION=70
+RULE_REGEX=63
+RULE_CLASS=29
+RULE_WHILE=32
+RULE_COLON_SLASH=75
+RULE_FUNC_EXIST=45
+RULE_DOT=13
+RULE_POST_IF=27
+RULE_PLUS_PLUS=11
+RULE_OWN=35
+RULE_NUMBER=59
+RULE_LOOP=49
+RULE_LPAREN=65
+RULE_FUNC_ARROW=17
+RULE_AT_SIGIL=16
+RULE_SHIFT=71
+RULE_EXTENDS=30
+RULE_INDEX_END=47
+RULE_COMPARE=69
+RULE_QUESTION_DOT=14
+RULE_RBRACKET=39
+RULE_COMPOUND_ASSIGN=7
+RULE_SUPER=44
+RULE_THEN=79
+RULE_UNARY_WORD=82
+RULE_LEADING_WHEN=55
+RULE_TASK=19
+RULE_DOT_DOT=4
+RULE_STATEMENT=66
+RULE_PLUS=8
+RULE_BY=38
+RULE_INDEX_SOAK=77
+RULE_CATCH=51
+RULE_CALL_START=20
+RULE_INDEX_PROTO=76
+RULE_IDENTIFIER=74
+RULE_COMMA=21
+RULE_TRY=50
+RULE_JS=62
+RULE_EQUAL=6
+RULE_INDENT=41
+RULE_HERECOMMENT=67
+RULE_ELLIPSIS=5
+RULE_FORIN=37
+RULE_SL_COMMENT=84
+RULE_PARAM_END=25
+T__86=86
+RULE_ML_COMMENT=83
+RULE_WHEN=33
+RULE_INDEX_START=46
+RULE_COLON=58
+RULE_MINUS=9
+RULE_STRING=60
+RULE_NEW=78
+RULE_LOGIC_WORD=80
+RULE_LOGIC=68
+RULE_RPAREN=64
+RULE_WS=85
+RULE_FOROF=36
+RULE_IF=73
+RULE_THIS=48
+RULE_UNARY=10
+RULE_RCURLY=57
+RULE_ELSE=54
+RULE_MATH=72
+RULE_FINALLY=52
+RULE_LCURLY=56
+RULE_QUESTION=43
+RULE_UNTIL=34
+'require'=86
diff --git a/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefileLexer.java b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefileLexer.java
new file mode 100644
index 0000000..2545d5d
--- /dev/null
+++ b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefileLexer.java
@@ -0,0 +1,4260 @@
+package csep.example.cake.ui.contentassist.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalCakefileLexer extends Lexer {
+ public static final int RULE_BOUND_FUNC_ARROW=18;
+ public static final int RULE_SWITCH=53;
+ public static final int RULE_THROW=28;
+ public static final int RULE_PARAM_START=24;
+ public static final int RULE_TERMINATOR=23;
+ public static final int RULE_CALL_END=22;
+ public static final int RULE_RETURN=26;
+ public static final int RULE_FOR=31;
+ public static final int RULE_BOOL=61;
+ public static final int RULE_LBRACKET=40;
+ public static final int RULE_DOUBLE_COLON=15;
+ public static final int RULE_MINUS_MINUS=12;
+ public static final int RULE_COMPARE_WORD=81;
+ public static final int RULE_OUTDENT=42;
+ public static final int EOF=-1;
+ public static final int RULE_RELATION=70;
+ public static final int RULE_REGEX=63;
+ public static final int RULE_CLASS=29;
+ public static final int RULE_WHILE=32;
+ public static final int RULE_COLON_SLASH=75;
+ public static final int RULE_FUNC_EXIST=45;
+ public static final int RULE_DOT=13;
+ public static final int RULE_POST_IF=27;
+ public static final int RULE_PLUS_PLUS=11;
+ public static final int RULE_OWN=35;
+ public static final int RULE_NUMBER=59;
+ public static final int RULE_LOOP=49;
+ public static final int RULE_LPAREN=65;
+ public static final int RULE_FUNC_ARROW=17;
+ public static final int RULE_AT_SIGIL=16;
+ public static final int RULE_SHIFT=71;
+ public static final int RULE_EXTENDS=30;
+ public static final int RULE_INDEX_END=47;
+ public static final int RULE_COMPARE=69;
+ public static final int RULE_QUESTION_DOT=14;
+ public static final int RULE_RBRACKET=39;
+ public static final int RULE_COMPOUND_ASSIGN=7;
+ public static final int RULE_SUPER=44;
+ public static final int RULE_THEN=79;
+ public static final int RULE_UNARY_WORD=82;
+ public static final int RULE_LEADING_WHEN=55;
+ public static final int RULE_TASK=19;
+ public static final int RULE_DOT_DOT=4;
+ public static final int RULE_STATEMENT=66;
+ public static final int RULE_PLUS=8;
+ public static final int RULE_BY=38;
+ public static final int RULE_CATCH=51;
+ public static final int RULE_INDEX_SOAK=77;
+ public static final int RULE_CALL_START=20;
+ public static final int RULE_COMMA=21;
+ public static final int RULE_IDENTIFIER=74;
+ public static final int RULE_INDEX_PROTO=76;
+ public static final int RULE_TRY=50;
+ public static final int RULE_INDENT=41;
+ public static final int RULE_EQUAL=6;
+ public static final int RULE_JS=62;
+ public static final int RULE_HERECOMMENT=67;
+ public static final int RULE_FORIN=37;
+ public static final int RULE_ELLIPSIS=5;
+ public static final int RULE_SL_COMMENT=84;
+ public static final int RULE_PARAM_END=25;
+ public static final int T__86=86;
+ public static final int RULE_WHEN=33;
+ public static final int RULE_ML_COMMENT=83;
+ public static final int RULE_INDEX_START=46;
+ public static final int RULE_MINUS=9;
+ public static final int RULE_COLON=58;
+ public static final int RULE_STRING=60;
+ public static final int RULE_NEW=78;
+ public static final int RULE_LOGIC_WORD=80;
+ public static final int RULE_LOGIC=68;
+ public static final int RULE_RPAREN=64;
+ public static final int RULE_WS=85;
+ public static final int RULE_FOROF=36;
+ public static final int RULE_UNARY=10;
+ public static final int RULE_THIS=48;
+ public static final int RULE_IF=73;
+ public static final int RULE_ELSE=54;
+ public static final int RULE_RCURLY=57;
+ public static final int RULE_FINALLY=52;
+ public static final int RULE_MATH=72;
+ public static final int RULE_UNTIL=34;
+ public static final int RULE_QUESTION=43;
+ public static final int RULE_LCURLY=56;
+
+ // delegates
+ // delegators
+
+ public InternalCakefileLexer() {;}
+ public InternalCakefileLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalCakefileLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g"; }
+
+ // $ANTLR start "T__86"
+ public final void mT__86() throws RecognitionException {
+ try {
+ int _type = T__86;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11:7: ( 'require' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11:9: 'require'
+ {
+ match("require");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__86"
+
+ // $ANTLR start "RULE_TASK"
+ public final void mRULE_TASK() throws RecognitionException {
+ try {
+ int _type = RULE_TASK;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16773:11: ( 'task' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16773:13: 'task'
+ {
+ match("task");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_TASK"
+
+ // $ANTLR start "RULE_ELLIPSIS"
+ public final void mRULE_ELLIPSIS() throws RecognitionException {
+ try {
+ int _type = RULE_ELLIPSIS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16775:15: ( '...' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16775:17: '...'
+ {
+ match("...");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ELLIPSIS"
+
+ // $ANTLR start "RULE_DOT_DOT"
+ public final void mRULE_DOT_DOT() throws RecognitionException {
+ try {
+ int _type = RULE_DOT_DOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16777:14: ( '..' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16777:16: '..'
+ {
+ match("..");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DOT_DOT"
+
+ // $ANTLR start "RULE_DOUBLE_COLON"
+ public final void mRULE_DOUBLE_COLON() throws RecognitionException {
+ try {
+ int _type = RULE_DOUBLE_COLON;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16779:19: ( '::' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16779:21: '::'
+ {
+ match("::");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DOUBLE_COLON"
+
+ // $ANTLR start "RULE_SHIFT"
+ public final void mRULE_SHIFT() throws RecognitionException {
+ try {
+ int _type = RULE_SHIFT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16781:12: ( ( '<<' | '>>' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16781:14: ( '<<' | '>>' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16781:14: ( '<<' | '>>' )
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0=='<') ) {
+ alt1=1;
+ }
+ else if ( (LA1_0=='>') ) {
+ alt1=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 1, 0, input);
+
+ throw nvae;
+ }
+ switch (alt1) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16781:15: '<<'
+ {
+ match("<<");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16781:20: '>>'
+ {
+ match(">>");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SHIFT"
+
+ // $ANTLR start "RULE_BOUND_FUNC_ARROW"
+ public final void mRULE_BOUND_FUNC_ARROW() throws RecognitionException {
+ try {
+ int _type = RULE_BOUND_FUNC_ARROW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16783:23: ( '=>' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16783:25: '=>'
+ {
+ match("=>");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_BOUND_FUNC_ARROW"
+
+ // $ANTLR start "RULE_FUNC_ARROW"
+ public final void mRULE_FUNC_ARROW() throws RecognitionException {
+ try {
+ int _type = RULE_FUNC_ARROW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16785:17: ( '->' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16785:19: '->'
+ {
+ match("->");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FUNC_ARROW"
+
+ // $ANTLR start "RULE_COMPARE"
+ public final void mRULE_COMPARE() throws RecognitionException {
+ try {
+ int _type = RULE_COMPARE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16787:14: ( ( '<' | '==' | '>' | '<=' | '>=' | '!=' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16787:16: ( '<' | '==' | '>' | '<=' | '>=' | '!=' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16787:16: ( '<' | '==' | '>' | '<=' | '>=' | '!=' )
+ int alt2=6;
+ switch ( input.LA(1) ) {
+ case '<':
+ {
+ int LA2_1 = input.LA(2);
+
+ if ( (LA2_1=='=') ) {
+ alt2=4;
+ }
+ else {
+ alt2=1;}
+ }
+ break;
+ case '=':
+ {
+ alt2=2;
+ }
+ break;
+ case '>':
+ {
+ int LA2_3 = input.LA(2);
+
+ if ( (LA2_3=='=') ) {
+ alt2=5;
+ }
+ else {
+ alt2=3;}
+ }
+ break;
+ case '!':
+ {
+ alt2=6;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt2) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16787:17: '<'
+ {
+ match('<');
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16787:21: '=='
+ {
+ match("==");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16787:26: '>'
+ {
+ match('>');
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16787:30: '<='
+ {
+ match("<=");
+
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16787:35: '>='
+ {
+ match(">=");
+
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16787:40: '!='
+ {
+ match("!=");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMPARE"
+
+ // $ANTLR start "RULE_COMPOUND_ASSIGN"
+ public final void mRULE_COMPOUND_ASSIGN() throws RecognitionException {
+ try {
+ int _type = RULE_COMPOUND_ASSIGN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16789:22: ( ( '+=' | '-=' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16789:24: ( '+=' | '-=' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16789:24: ( '+=' | '-=' )
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0=='+') ) {
+ alt3=1;
+ }
+ else if ( (LA3_0=='-') ) {
+ alt3=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 3, 0, input);
+
+ throw nvae;
+ }
+ switch (alt3) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16789:25: '+='
+ {
+ match("+=");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16789:30: '-='
+ {
+ match("-=");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMPOUND_ASSIGN"
+
+ // $ANTLR start "RULE_PLUS_PLUS"
+ public final void mRULE_PLUS_PLUS() throws RecognitionException {
+ try {
+ int _type = RULE_PLUS_PLUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16791:16: ( '++' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16791:18: '++'
+ {
+ match("++");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PLUS_PLUS"
+
+ // $ANTLR start "RULE_MINUS_MINUS"
+ public final void mRULE_MINUS_MINUS() throws RecognitionException {
+ try {
+ int _type = RULE_MINUS_MINUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16793:18: ( '--' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16793:20: '--'
+ {
+ match("--");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_MINUS_MINUS"
+
+ // $ANTLR start "RULE_PARAM_END"
+ public final void mRULE_PARAM_END() throws RecognitionException {
+ try {
+ int _type = RULE_PARAM_END;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16795:16: ( '**)' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16795:18: '**)'
+ {
+ match("**)");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PARAM_END"
+
+ // $ANTLR start "RULE_PARAM_START"
+ public final void mRULE_PARAM_START() throws RecognitionException {
+ try {
+ int _type = RULE_PARAM_START;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16797:18: ( '(**' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16797:20: '(**'
+ {
+ match("(**");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PARAM_START"
+
+ // $ANTLR start "RULE_AT_SIGIL"
+ public final void mRULE_AT_SIGIL() throws RecognitionException {
+ try {
+ int _type = RULE_AT_SIGIL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16799:15: ( '@' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16799:17: '@'
+ {
+ match('@');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_AT_SIGIL"
+
+ // $ANTLR start "RULE_BOOL"
+ public final void mRULE_BOOL() throws RecognitionException {
+ try {
+ int _type = RULE_BOOL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:11: ( ( 'true' | 'false' | 'undefined' | 'null' | 'on' | 'no' | 'yes' | 'off' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:13: ( 'true' | 'false' | 'undefined' | 'null' | 'on' | 'no' | 'yes' | 'off' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:13: ( 'true' | 'false' | 'undefined' | 'null' | 'on' | 'no' | 'yes' | 'off' )
+ int alt4=8;
+ alt4 = dfa4.predict(input);
+ switch (alt4) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:14: 'true'
+ {
+ match("true");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:21: 'false'
+ {
+ match("false");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:29: 'undefined'
+ {
+ match("undefined");
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:41: 'null'
+ {
+ match("null");
+
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:48: 'on'
+ {
+ match("on");
+
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:53: 'no'
+ {
+ match("no");
+
+
+ }
+ break;
+ case 7 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:58: 'yes'
+ {
+ match("yes");
+
+
+ }
+ break;
+ case 8 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16801:64: 'off'
+ {
+ match("off");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_BOOL"
+
+ // $ANTLR start "RULE_BY"
+ public final void mRULE_BY() throws RecognitionException {
+ try {
+ int _type = RULE_BY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16803:9: ( 'by' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16803:11: 'by'
+ {
+ match("by");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_BY"
+
+ // $ANTLR start "RULE_CALL_END"
+ public final void mRULE_CALL_END() throws RecognitionException {
+ try {
+ int _type = RULE_CALL_END;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16805:15: ( '*)' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16805:17: '*)'
+ {
+ match("*)");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CALL_END"
+
+ // $ANTLR start "RULE_CALL_START"
+ public final void mRULE_CALL_START() throws RecognitionException {
+ try {
+ int _type = RULE_CALL_START;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16807:17: ( '(*' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16807:19: '(*'
+ {
+ match("(*");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CALL_START"
+
+ // $ANTLR start "RULE_CATCH"
+ public final void mRULE_CATCH() throws RecognitionException {
+ try {
+ int _type = RULE_CATCH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16809:12: ( 'catch' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16809:14: 'catch'
+ {
+ match("catch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CATCH"
+
+ // $ANTLR start "RULE_CLASS"
+ public final void mRULE_CLASS() throws RecognitionException {
+ try {
+ int _type = RULE_CLASS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16811:12: ( 'class' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16811:14: 'class'
+ {
+ match("class");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CLASS"
+
+ // $ANTLR start "RULE_COLON"
+ public final void mRULE_COLON() throws RecognitionException {
+ try {
+ int _type = RULE_COLON;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16813:12: ( ':' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16813:14: ':'
+ {
+ match(':');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COLON"
+
+ // $ANTLR start "RULE_COLON_SLASH"
+ public final void mRULE_COLON_SLASH() throws RecognitionException {
+ try {
+ int _type = RULE_COLON_SLASH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16815:18: ( 'dummy COLON_SLASH' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16815:20: 'dummy COLON_SLASH'
+ {
+ match("dummy COLON_SLASH");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COLON_SLASH"
+
+ // $ANTLR start "RULE_COMMA"
+ public final void mRULE_COMMA() throws RecognitionException {
+ try {
+ int _type = RULE_COMMA;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16817:12: ( ',' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16817:14: ','
+ {
+ match(',');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMMA"
+
+ // $ANTLR start "RULE_DOT"
+ public final void mRULE_DOT() throws RecognitionException {
+ try {
+ int _type = RULE_DOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16819:10: ( '.' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16819:12: '.'
+ {
+ match('.');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DOT"
+
+ // $ANTLR start "RULE_ELSE"
+ public final void mRULE_ELSE() throws RecognitionException {
+ try {
+ int _type = RULE_ELSE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16821:11: ( 'else' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16821:13: 'else'
+ {
+ match("else");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ELSE"
+
+ // $ANTLR start "RULE_EQUAL"
+ public final void mRULE_EQUAL() throws RecognitionException {
+ try {
+ int _type = RULE_EQUAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16823:12: ( '=' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16823:14: '='
+ {
+ match('=');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_EQUAL"
+
+ // $ANTLR start "RULE_EXTENDS"
+ public final void mRULE_EXTENDS() throws RecognitionException {
+ try {
+ int _type = RULE_EXTENDS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16825:14: ( 'extends' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16825:16: 'extends'
+ {
+ match("extends");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_EXTENDS"
+
+ // $ANTLR start "RULE_FINALLY"
+ public final void mRULE_FINALLY() throws RecognitionException {
+ try {
+ int _type = RULE_FINALLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16827:14: ( 'finally' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16827:16: 'finally'
+ {
+ match("finally");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FINALLY"
+
+ // $ANTLR start "RULE_FOR"
+ public final void mRULE_FOR() throws RecognitionException {
+ try {
+ int _type = RULE_FOR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16829:10: ( 'for' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16829:12: 'for'
+ {
+ match("for");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FOR"
+
+ // $ANTLR start "RULE_FORIN"
+ public final void mRULE_FORIN() throws RecognitionException {
+ try {
+ int _type = RULE_FORIN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16831:12: ( 'in' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16831:14: 'in'
+ {
+ match("in");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FORIN"
+
+ // $ANTLR start "RULE_FOROF"
+ public final void mRULE_FOROF() throws RecognitionException {
+ try {
+ int _type = RULE_FOROF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16833:12: ( 'of' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16833:14: 'of'
+ {
+ match("of");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FOROF"
+
+ // $ANTLR start "RULE_FUNC_EXIST"
+ public final void mRULE_FUNC_EXIST() throws RecognitionException {
+ try {
+ int _type = RULE_FUNC_EXIST;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16835:17: ( 'dummy FUNC_EXIST' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16835:19: 'dummy FUNC_EXIST'
+ {
+ match("dummy FUNC_EXIST");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FUNC_EXIST"
+
+ // $ANTLR start "RULE_HERECOMMENT"
+ public final void mRULE_HERECOMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_HERECOMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16837:18: ( 'dummy HERECOMMENT' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16837:20: 'dummy HERECOMMENT'
+ {
+ match("dummy HERECOMMENT");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_HERECOMMENT"
+
+ // $ANTLR start "RULE_IF"
+ public final void mRULE_IF() throws RecognitionException {
+ try {
+ int _type = RULE_IF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16839:9: ( ( 'if' | 'unless' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16839:11: ( 'if' | 'unless' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16839:11: ( 'if' | 'unless' )
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0=='i') ) {
+ alt5=1;
+ }
+ else if ( (LA5_0=='u') ) {
+ alt5=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 5, 0, input);
+
+ throw nvae;
+ }
+ switch (alt5) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16839:12: 'if'
+ {
+ match("if");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16839:17: 'unless'
+ {
+ match("unless");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_IF"
+
+ // $ANTLR start "RULE_INDENT"
+ public final void mRULE_INDENT() throws RecognitionException {
+ try {
+ int _type = RULE_INDENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16841:13: ( '{*' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16841:15: '{*'
+ {
+ match("{*");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDENT"
+
+ // $ANTLR start "RULE_INDEX_END"
+ public final void mRULE_INDEX_END() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_END;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16843:16: ( '*]' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16843:18: '*]'
+ {
+ match("*]");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_END"
+
+ // $ANTLR start "RULE_INDEX_PROTO"
+ public final void mRULE_INDEX_PROTO() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_PROTO;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16845:18: ( 'dummy INDEX_PROTO' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16845:20: 'dummy INDEX_PROTO'
+ {
+ match("dummy INDEX_PROTO");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_PROTO"
+
+ // $ANTLR start "RULE_INDEX_SOAK"
+ public final void mRULE_INDEX_SOAK() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_SOAK;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16847:17: ( 'dummy INDEX_SOAK' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16847:19: 'dummy INDEX_SOAK'
+ {
+ match("dummy INDEX_SOAK");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_SOAK"
+
+ // $ANTLR start "RULE_INDEX_START"
+ public final void mRULE_INDEX_START() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_START;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16849:18: ( '[*' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16849:20: '[*'
+ {
+ match("[*");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_START"
+
+ // $ANTLR start "RULE_JS"
+ public final void mRULE_JS() throws RecognitionException {
+ try {
+ int _type = RULE_JS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16851:9: ( 'dummy JS' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16851:11: 'dummy JS'
+ {
+ match("dummy JS");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_JS"
+
+ // $ANTLR start "RULE_LBRACKET"
+ public final void mRULE_LBRACKET() throws RecognitionException {
+ try {
+ int _type = RULE_LBRACKET;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16853:15: ( '[' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16853:17: '['
+ {
+ match('[');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LBRACKET"
+
+ // $ANTLR start "RULE_LCURLY"
+ public final void mRULE_LCURLY() throws RecognitionException {
+ try {
+ int _type = RULE_LCURLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16855:13: ( 'dummy LCURLY' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16855:15: 'dummy LCURLY'
+ {
+ match("dummy LCURLY");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LCURLY"
+
+ // $ANTLR start "RULE_LEADING_WHEN"
+ public final void mRULE_LEADING_WHEN() throws RecognitionException {
+ try {
+ int _type = RULE_LEADING_WHEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16857:19: ( 'dummy LEADING_WHEN' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16857:21: 'dummy LEADING_WHEN'
+ {
+ match("dummy LEADING_WHEN");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LEADING_WHEN"
+
+ // $ANTLR start "RULE_LOGIC"
+ public final void mRULE_LOGIC() throws RecognitionException {
+ try {
+ int _type = RULE_LOGIC;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16859:12: ( ( '&&' | '||' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16859:14: ( '&&' | '||' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16859:14: ( '&&' | '||' )
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0=='&') ) {
+ alt6=1;
+ }
+ else if ( (LA6_0=='|') ) {
+ alt6=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 6, 0, input);
+
+ throw nvae;
+ }
+ switch (alt6) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16859:15: '&&'
+ {
+ match("&&");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16859:20: '||'
+ {
+ match("||");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOGIC"
+
+ // $ANTLR start "RULE_LOOP"
+ public final void mRULE_LOOP() throws RecognitionException {
+ try {
+ int _type = RULE_LOOP;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16861:11: ( 'loop' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16861:13: 'loop'
+ {
+ match("loop");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOOP"
+
+ // $ANTLR start "RULE_LPAREN"
+ public final void mRULE_LPAREN() throws RecognitionException {
+ try {
+ int _type = RULE_LPAREN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16863:13: ( '(' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16863:15: '('
+ {
+ match('(');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LPAREN"
+
+ // $ANTLR start "RULE_MATH"
+ public final void mRULE_MATH() throws RecognitionException {
+ try {
+ int _type = RULE_MATH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16865:11: ( ( '*' | '/' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16865:13: ( '*' | '/' )
+ {
+ if ( input.LA(1)=='*'||input.LA(1)=='/' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_MATH"
+
+ // $ANTLR start "RULE_MINUS"
+ public final void mRULE_MINUS() throws RecognitionException {
+ try {
+ int _type = RULE_MINUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16867:12: ( '-' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16867:14: '-'
+ {
+ match('-');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_MINUS"
+
+ // $ANTLR start "RULE_NEW"
+ public final void mRULE_NEW() throws RecognitionException {
+ try {
+ int _type = RULE_NEW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16869:10: ( 'new' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16869:12: 'new'
+ {
+ match("new");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_NEW"
+
+ // $ANTLR start "RULE_NUMBER"
+ public final void mRULE_NUMBER() throws RecognitionException {
+ try {
+ int _type = RULE_NUMBER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16871:13: ( ( '0' .. '9' )+ )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16871:15: ( '0' .. '9' )+
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16871:15: ( '0' .. '9' )+
+ int cnt7=0;
+ loop7:
+ do {
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( ((LA7_0>='0' && LA7_0<='9')) ) {
+ alt7=1;
+ }
+
+
+ switch (alt7) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16871:16: '0' .. '9'
+ {
+ matchRange('0','9');
+
+ }
+ break;
+
+ default :
+ if ( cnt7 >= 1 ) break loop7;
+ EarlyExitException eee =
+ new EarlyExitException(7, input);
+ throw eee;
+ }
+ cnt7++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_NUMBER"
+
+ // $ANTLR start "RULE_OUTDENT"
+ public final void mRULE_OUTDENT() throws RecognitionException {
+ try {
+ int _type = RULE_OUTDENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16873:14: ( '*}' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16873:16: '*}'
+ {
+ match("*}");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_OUTDENT"
+
+ // $ANTLR start "RULE_OWN"
+ public final void mRULE_OWN() throws RecognitionException {
+ try {
+ int _type = RULE_OWN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16875:10: ( 'own' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16875:12: 'own'
+ {
+ match("own");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_OWN"
+
+ // $ANTLR start "RULE_PLUS"
+ public final void mRULE_PLUS() throws RecognitionException {
+ try {
+ int _type = RULE_PLUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16877:11: ( '+' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16877:13: '+'
+ {
+ match('+');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PLUS"
+
+ // $ANTLR start "RULE_POST_IF"
+ public final void mRULE_POST_IF() throws RecognitionException {
+ try {
+ int _type = RULE_POST_IF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16879:14: ( 'dummy POST_IF' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16879:16: 'dummy POST_IF'
+ {
+ match("dummy POST_IF");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_POST_IF"
+
+ // $ANTLR start "RULE_QUESTION"
+ public final void mRULE_QUESTION() throws RecognitionException {
+ try {
+ int _type = RULE_QUESTION;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16881:15: ( '?' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16881:17: '?'
+ {
+ match('?');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_QUESTION"
+
+ // $ANTLR start "RULE_QUESTION_DOT"
+ public final void mRULE_QUESTION_DOT() throws RecognitionException {
+ try {
+ int _type = RULE_QUESTION_DOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16883:19: ( '?.' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16883:21: '?.'
+ {
+ match("?.");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_QUESTION_DOT"
+
+ // $ANTLR start "RULE_RBRACKET"
+ public final void mRULE_RBRACKET() throws RecognitionException {
+ try {
+ int _type = RULE_RBRACKET;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16885:15: ( ']' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16885:17: ']'
+ {
+ match(']');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RBRACKET"
+
+ // $ANTLR start "RULE_RCURLY"
+ public final void mRULE_RCURLY() throws RecognitionException {
+ try {
+ int _type = RULE_RCURLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16887:13: ( 'dummy RCURLY' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16887:15: 'dummy RCURLY'
+ {
+ match("dummy RCURLY");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RCURLY"
+
+ // $ANTLR start "RULE_REGEX"
+ public final void mRULE_REGEX() throws RecognitionException {
+ try {
+ int _type = RULE_REGEX;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16889:12: ( '///' ( options {greedy=false; } : . )* '///' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16889:14: '///' ( options {greedy=false; } : . )* '///'
+ {
+ match("///");
+
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16889:20: ( options {greedy=false; } : . )*
+ loop8:
+ do {
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='/') ) {
+ int LA8_1 = input.LA(2);
+
+ if ( (LA8_1=='/') ) {
+ int LA8_3 = input.LA(3);
+
+ if ( (LA8_3=='/') ) {
+ alt8=2;
+ }
+ else if ( ((LA8_3>='\u0000' && LA8_3<='.')||(LA8_3>='0' && LA8_3<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ }
+ else if ( ((LA8_1>='\u0000' && LA8_1<='.')||(LA8_1>='0' && LA8_1<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ }
+ else if ( ((LA8_0>='\u0000' && LA8_0<='.')||(LA8_0>='0' && LA8_0<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ switch (alt8) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16889:48: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop8;
+ }
+ } while (true);
+
+ match("///");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_REGEX"
+
+ // $ANTLR start "RULE_RELATION"
+ public final void mRULE_RELATION() throws RecognitionException {
+ try {
+ int _type = RULE_RELATION;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16891:15: ( ( 'in' | 'of' | 'instanceof' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16891:17: ( 'in' | 'of' | 'instanceof' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16891:17: ( 'in' | 'of' | 'instanceof' )
+ int alt9=3;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0=='i') ) {
+ int LA9_1 = input.LA(2);
+
+ if ( (LA9_1=='n') ) {
+ int LA9_3 = input.LA(3);
+
+ if ( (LA9_3=='s') ) {
+ alt9=3;
+ }
+ else {
+ alt9=1;}
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA9_0=='o') ) {
+ alt9=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 0, input);
+
+ throw nvae;
+ }
+ switch (alt9) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16891:18: 'in'
+ {
+ match("in");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16891:23: 'of'
+ {
+ match("of");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16891:28: 'instanceof'
+ {
+ match("instanceof");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RELATION"
+
+ // $ANTLR start "RULE_RETURN"
+ public final void mRULE_RETURN() throws RecognitionException {
+ try {
+ int _type = RULE_RETURN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16893:13: ( 'return' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16893:15: 'return'
+ {
+ match("return");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RETURN"
+
+ // $ANTLR start "RULE_RPAREN"
+ public final void mRULE_RPAREN() throws RecognitionException {
+ try {
+ int _type = RULE_RPAREN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16895:13: ( ')' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16895:15: ')'
+ {
+ match(')');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RPAREN"
+
+ // $ANTLR start "RULE_STATEMENT"
+ public final void mRULE_STATEMENT() throws RecognitionException {
+ try {
+ int _type = RULE_STATEMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16897:16: ( ( 'break' | 'continue' | 'debugger' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16897:18: ( 'break' | 'continue' | 'debugger' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16897:18: ( 'break' | 'continue' | 'debugger' )
+ int alt10=3;
+ switch ( input.LA(1) ) {
+ case 'b':
+ {
+ alt10=1;
+ }
+ break;
+ case 'c':
+ {
+ alt10=2;
+ }
+ break;
+ case 'd':
+ {
+ alt10=3;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 10, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt10) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16897:19: 'break'
+ {
+ match("break");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16897:27: 'continue'
+ {
+ match("continue");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16897:38: 'debugger'
+ {
+ match("debugger");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STATEMENT"
+
+ // $ANTLR start "RULE_STRING"
+ public final void mRULE_STRING() throws RecognitionException {
+ try {
+ int _type = RULE_STRING;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:13: ( ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:15: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:15: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"' )
+ int alt17=4;
+ int LA17_0 = input.LA(1);
+
+ if ( (LA17_0=='\'') ) {
+ int LA17_1 = input.LA(2);
+
+ if ( (LA17_1=='\'') ) {
+ int LA17_3 = input.LA(3);
+
+ if ( (LA17_3=='\'') ) {
+ alt17=1;
+ }
+ else {
+ alt17=2;}
+ }
+ else if ( ((LA17_1>='\u0000' && LA17_1<='&')||(LA17_1>='(' && LA17_1<='\uFFFF')) ) {
+ alt17=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA17_0=='\"') ) {
+ int LA17_2 = input.LA(2);
+
+ if ( (LA17_2=='\"') ) {
+ int LA17_5 = input.LA(3);
+
+ if ( (LA17_5=='\"') ) {
+ alt17=3;
+ }
+ else {
+ alt17=4;}
+ }
+ else if ( ((LA17_2>='\u0000' && LA17_2<='!')||(LA17_2>='#' && LA17_2<='\uFFFF')) ) {
+ alt17=4;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 2, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 0, input);
+
+ throw nvae;
+ }
+ switch (alt17) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:16: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
+ {
+ match("'''");
+
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:25: ( options {greedy=false; } : . )*
+ loop11:
+ do {
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0=='\'') ) {
+ int LA11_1 = input.LA(2);
+
+ if ( (LA11_1=='\'') ) {
+ int LA11_3 = input.LA(3);
+
+ if ( (LA11_3=='\'') ) {
+ alt11=2;
+ }
+ else if ( ((LA11_3>='\u0000' && LA11_3<='&')||(LA11_3>='(' && LA11_3<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ }
+ else if ( ((LA11_1>='\u0000' && LA11_1<='&')||(LA11_1>='(' && LA11_1<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ }
+ else if ( ((LA11_0>='\u0000' && LA11_0<='&')||(LA11_0>='(' && LA11_0<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ switch (alt11) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:53: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop11;
+ }
+ } while (true);
+
+ match("'''");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:66: '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\''
+ {
+ match('\'');
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:71: (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )?
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( ((LA13_0>='\u0000' && LA13_0<='&')||(LA13_0>='(' && LA13_0<='\uFFFF')) ) {
+ alt13=1;
+ }
+ switch (alt13) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:72: ~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )*
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:80: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )*
+ loop12:
+ do {
+ int alt12=3;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0=='\\') ) {
+ alt12=1;
+ }
+ else if ( ((LA12_0>='\u0000' && LA12_0<='&')||(LA12_0>='(' && LA12_0<='[')||(LA12_0>=']' && LA12_0<='\uFFFF')) ) {
+ alt12=2;
+ }
+
+
+ switch (alt12) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:81: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' )
+ {
+ match('\\');
+ if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||(input.LA(1)>='t' && input.LA(1)<='u') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:126: ~ ( ( '\\\\' | '\\'' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop12;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ match('\'');
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:150: '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"'
+ {
+ match("\"\"\"");
+
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:156: ( options {greedy=false; } : . )*
+ loop14:
+ do {
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0=='\"') ) {
+ int LA14_1 = input.LA(2);
+
+ if ( (LA14_1=='\"') ) {
+ int LA14_3 = input.LA(3);
+
+ if ( (LA14_3=='\"') ) {
+ alt14=2;
+ }
+ else if ( ((LA14_3>='\u0000' && LA14_3<='!')||(LA14_3>='#' && LA14_3<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ }
+ else if ( ((LA14_1>='\u0000' && LA14_1<='!')||(LA14_1>='#' && LA14_1<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ }
+ else if ( ((LA14_0>='\u0000' && LA14_0<='!')||(LA14_0>='#' && LA14_0<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ switch (alt14) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:184: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop14;
+ }
+ } while (true);
+
+ match("\"\"\"");
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:194: '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"'
+ {
+ match('\"');
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:198: (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )?
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( ((LA16_0>='\u0000' && LA16_0<='!')||(LA16_0>='#' && LA16_0<='\uFFFF')) ) {
+ alt16=1;
+ }
+ switch (alt16) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:199: ~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )*
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:206: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )*
+ loop15:
+ do {
+ int alt15=3;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0=='\\') ) {
+ alt15=1;
+ }
+ else if ( ((LA15_0>='\u0000' && LA15_0<='!')||(LA15_0>='#' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) {
+ alt15=2;
+ }
+
+
+ switch (alt15) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:207: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' )
+ {
+ match('\\');
+ if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||(input.LA(1)>='t' && input.LA(1)<='u') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16899:252: ~ ( ( '\\\\' | '\"' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop15;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ match('\"');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STRING"
+
+ // $ANTLR start "RULE_SUPER"
+ public final void mRULE_SUPER() throws RecognitionException {
+ try {
+ int _type = RULE_SUPER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16901:12: ( 'super' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16901:14: 'super'
+ {
+ match("super");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SUPER"
+
+ // $ANTLR start "RULE_SWITCH"
+ public final void mRULE_SWITCH() throws RecognitionException {
+ try {
+ int _type = RULE_SWITCH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16903:13: ( 'switch' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16903:15: 'switch'
+ {
+ match("switch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SWITCH"
+
+ // $ANTLR start "RULE_TERMINATOR"
+ public final void mRULE_TERMINATOR() throws RecognitionException {
+ try {
+ int _type = RULE_TERMINATOR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16905:17: ( ( '\\n' )+ )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16905:19: ( '\\n' )+
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16905:19: ( '\\n' )+
+ int cnt18=0;
+ loop18:
+ do {
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0=='\n') ) {
+ alt18=1;
+ }
+
+
+ switch (alt18) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16905:19: '\\n'
+ {
+ match('\n');
+
+ }
+ break;
+
+ default :
+ if ( cnt18 >= 1 ) break loop18;
+ EarlyExitException eee =
+ new EarlyExitException(18, input);
+ throw eee;
+ }
+ cnt18++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_TERMINATOR"
+
+ // $ANTLR start "RULE_THEN"
+ public final void mRULE_THEN() throws RecognitionException {
+ try {
+ int _type = RULE_THEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16907:11: ( 'then' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16907:13: 'then'
+ {
+ match("then");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_THEN"
+
+ // $ANTLR start "RULE_THIS"
+ public final void mRULE_THIS() throws RecognitionException {
+ try {
+ int _type = RULE_THIS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16909:11: ( 'this' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16909:13: 'this'
+ {
+ match("this");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_THIS"
+
+ // $ANTLR start "RULE_THROW"
+ public final void mRULE_THROW() throws RecognitionException {
+ try {
+ int _type = RULE_THROW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16911:12: ( 'throw' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16911:14: 'throw'
+ {
+ match("throw");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_THROW"
+
+ // $ANTLR start "RULE_TRY"
+ public final void mRULE_TRY() throws RecognitionException {
+ try {
+ int _type = RULE_TRY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16913:10: ( 'try' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16913:12: 'try'
+ {
+ match("try");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_TRY"
+
+ // $ANTLR start "RULE_UNARY"
+ public final void mRULE_UNARY() throws RecognitionException {
+ try {
+ int _type = RULE_UNARY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16915:12: ( ( '!' | '~' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16915:14: ( '!' | '~' )
+ {
+ if ( input.LA(1)=='!'||input.LA(1)=='~' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_UNARY"
+
+ // $ANTLR start "RULE_UNTIL"
+ public final void mRULE_UNTIL() throws RecognitionException {
+ try {
+ int _type = RULE_UNTIL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16917:12: ( 'until' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16917:14: 'until'
+ {
+ match("until");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_UNTIL"
+
+ // $ANTLR start "RULE_WHEN"
+ public final void mRULE_WHEN() throws RecognitionException {
+ try {
+ int _type = RULE_WHEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16919:11: ( 'when' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16919:13: 'when'
+ {
+ match("when");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WHEN"
+
+ // $ANTLR start "RULE_WHILE"
+ public final void mRULE_WHILE() throws RecognitionException {
+ try {
+ int _type = RULE_WHILE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16921:12: ( 'while' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16921:14: 'while'
+ {
+ match("while");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WHILE"
+
+ // $ANTLR start "RULE_LOGIC_WORD"
+ public final void mRULE_LOGIC_WORD() throws RecognitionException {
+ try {
+ int _type = RULE_LOGIC_WORD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16923:17: ( ( 'and' | 'or' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16923:19: ( 'and' | 'or' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16923:19: ( 'and' | 'or' )
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0=='a') ) {
+ alt19=1;
+ }
+ else if ( (LA19_0=='o') ) {
+ alt19=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 19, 0, input);
+
+ throw nvae;
+ }
+ switch (alt19) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16923:20: 'and'
+ {
+ match("and");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16923:26: 'or'
+ {
+ match("or");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOGIC_WORD"
+
+ // $ANTLR start "RULE_COMPARE_WORD"
+ public final void mRULE_COMPARE_WORD() throws RecognitionException {
+ try {
+ int _type = RULE_COMPARE_WORD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16925:19: ( ( 'isnt' | 'is' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16925:21: ( 'isnt' | 'is' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16925:21: ( 'isnt' | 'is' )
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0=='i') ) {
+ int LA20_1 = input.LA(2);
+
+ if ( (LA20_1=='s') ) {
+ int LA20_2 = input.LA(3);
+
+ if ( (LA20_2=='n') ) {
+ alt20=1;
+ }
+ else {
+ alt20=2;}
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 20, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 20, 0, input);
+
+ throw nvae;
+ }
+ switch (alt20) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16925:22: 'isnt'
+ {
+ match("isnt");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16925:29: 'is'
+ {
+ match("is");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMPARE_WORD"
+
+ // $ANTLR start "RULE_UNARY_WORD"
+ public final void mRULE_UNARY_WORD() throws RecognitionException {
+ try {
+ int _type = RULE_UNARY_WORD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16927:17: ( ( 'new' | 'do' | 'not' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16927:19: ( 'new' | 'do' | 'not' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16927:19: ( 'new' | 'do' | 'not' )
+ int alt21=3;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0=='n') ) {
+ int LA21_1 = input.LA(2);
+
+ if ( (LA21_1=='e') ) {
+ alt21=1;
+ }
+ else if ( (LA21_1=='o') ) {
+ alt21=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA21_0=='d') ) {
+ alt21=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 0, input);
+
+ throw nvae;
+ }
+ switch (alt21) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16927:20: 'new'
+ {
+ match("new");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16927:26: 'do'
+ {
+ match("do");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16927:31: 'not'
+ {
+ match("not");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_UNARY_WORD"
+
+ // $ANTLR start "RULE_ML_COMMENT"
+ public final void mRULE_ML_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_ML_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16929:17: ( '###' ~ ( '#' ) ( options {greedy=false; } : . )* '###' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16929:19: '###' ~ ( '#' ) ( options {greedy=false; } : . )* '###'
+ {
+ match("###");
+
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\"')||(input.LA(1)>='$' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16929:32: ( options {greedy=false; } : . )*
+ loop22:
+ do {
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( (LA22_0=='#') ) {
+ int LA22_1 = input.LA(2);
+
+ if ( (LA22_1=='#') ) {
+ int LA22_3 = input.LA(3);
+
+ if ( (LA22_3=='#') ) {
+ alt22=2;
+ }
+ else if ( ((LA22_3>='\u0000' && LA22_3<='\"')||(LA22_3>='$' && LA22_3<='\uFFFF')) ) {
+ alt22=1;
+ }
+
+
+ }
+ else if ( ((LA22_1>='\u0000' && LA22_1<='\"')||(LA22_1>='$' && LA22_1<='\uFFFF')) ) {
+ alt22=1;
+ }
+
+
+ }
+ else if ( ((LA22_0>='\u0000' && LA22_0<='\"')||(LA22_0>='$' && LA22_0<='\uFFFF')) ) {
+ alt22=1;
+ }
+
+
+ switch (alt22) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16929:60: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop22;
+ }
+ } while (true);
+
+ match("###");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ML_COMMENT"
+
+ // $ANTLR start "RULE_SL_COMMENT"
+ public final void mRULE_SL_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_SL_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16931:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16931:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+ {
+ match('#');
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16931:23: (~ ( ( '\\n' | '\\r' ) ) )*
+ loop23:
+ do {
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( ((LA23_0>='\u0000' && LA23_0<='\t')||(LA23_0>='\u000B' && LA23_0<='\f')||(LA23_0>='\u000E' && LA23_0<='\uFFFF')) ) {
+ alt23=1;
+ }
+
+
+ switch (alt23) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16931:23: ~ ( ( '\\n' | '\\r' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop23;
+ }
+ } while (true);
+
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16931:39: ( ( '\\r' )? '\\n' )?
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( (LA25_0=='\n'||LA25_0=='\r') ) {
+ alt25=1;
+ }
+ switch (alt25) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16931:40: ( '\\r' )? '\\n'
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16931:40: ( '\\r' )?
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0=='\r') ) {
+ alt24=1;
+ }
+ switch (alt24) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16931:40: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SL_COMMENT"
+
+ // $ANTLR start "RULE_WS"
+ public final void mRULE_WS() throws RecognitionException {
+ try {
+ int _type = RULE_WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16933:9: ( ( ' ' | '\\t' )+ )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16933:11: ( ' ' | '\\t' )+
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16933:11: ( ' ' | '\\t' )+
+ int cnt26=0;
+ loop26:
+ do {
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0=='\t'||LA26_0==' ') ) {
+ alt26=1;
+ }
+
+
+ switch (alt26) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:
+ {
+ if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt26 >= 1 ) break loop26;
+ EarlyExitException eee =
+ new EarlyExitException(26, input);
+ throw eee;
+ }
+ cnt26++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WS"
+
+ // $ANTLR start "RULE_IDENTIFIER"
+ public final void mRULE_IDENTIFIER() throws RecognitionException {
+ try {
+ int _type = RULE_IDENTIFIER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16935:17: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16935:19: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16935:19: ( '^' )?
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( (LA27_0=='^') ) {
+ alt27=1;
+ }
+ switch (alt27) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16935:19: '^'
+ {
+ match('^');
+
+ }
+ break;
+
+ }
+
+ if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16935:48: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ loop28:
+ do {
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( ((LA28_0>='0' && LA28_0<='9')||(LA28_0>='A' && LA28_0<='Z')||LA28_0=='_'||(LA28_0>='a' && LA28_0<='z')) ) {
+ alt28=1;
+ }
+
+
+ switch (alt28) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop28;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_IDENTIFIER"
+
+ public void mTokens() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:8: ( T__86 | RULE_TASK | RULE_ELLIPSIS | RULE_DOT_DOT | RULE_DOUBLE_COLON | RULE_SHIFT | RULE_BOUND_FUNC_ARROW | RULE_FUNC_ARROW | RULE_COMPARE | RULE_COMPOUND_ASSIGN | RULE_PLUS_PLUS | RULE_MINUS_MINUS | RULE_PARAM_END | RULE_PARAM_START | RULE_AT_SIGIL | RULE_BOOL | RULE_BY | RULE_CALL_END | RULE_CALL_START | RULE_CATCH | RULE_CLASS | RULE_COLON | RULE_COLON_SLASH | RULE_COMMA | RULE_DOT | RULE_ELSE | RULE_EQUAL | RULE_EXTENDS | RULE_FINALLY | RULE_FOR | RULE_FORIN | RULE_FOROF | RULE_FUNC_EXIST | RULE_HERECOMMENT | RULE_IF | RULE_INDENT | RULE_INDEX_END | RULE_INDEX_PROTO | RULE_INDEX_SOAK | RULE_INDEX_START | RULE_JS | RULE_LBRACKET | RULE_LCURLY | RULE_LEADING_WHEN | RULE_LOGIC | RULE_LOOP | RULE_LPAREN | RULE_MATH | RULE_MINUS | RULE_NEW | RULE_NUMBER | RULE_OUTDENT | RULE_OWN | RULE_PLUS | RULE_POST_IF | RULE_QUESTION | RULE_QUESTION_DOT | RULE_RBRACKET | RULE_RCURLY | RULE_REGEX | RULE_RELATION | RULE_RETURN | RULE_RPAREN | RULE_STATEMENT | RULE_STRING | RULE_SUPER | RULE_SWITCH | RULE_TERMINATOR | RULE_THEN | RULE_THIS | RULE_THROW | RULE_TRY | RULE_UNARY | RULE_UNTIL | RULE_WHEN | RULE_WHILE | RULE_LOGIC_WORD | RULE_COMPARE_WORD | RULE_UNARY_WORD | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_IDENTIFIER )
+ int alt29=83;
+ alt29 = dfa29.predict(input);
+ switch (alt29) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:10: T__86
+ {
+ mT__86();
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:16: RULE_TASK
+ {
+ mRULE_TASK();
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:26: RULE_ELLIPSIS
+ {
+ mRULE_ELLIPSIS();
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:40: RULE_DOT_DOT
+ {
+ mRULE_DOT_DOT();
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:53: RULE_DOUBLE_COLON
+ {
+ mRULE_DOUBLE_COLON();
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:71: RULE_SHIFT
+ {
+ mRULE_SHIFT();
+
+ }
+ break;
+ case 7 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:82: RULE_BOUND_FUNC_ARROW
+ {
+ mRULE_BOUND_FUNC_ARROW();
+
+ }
+ break;
+ case 8 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:104: RULE_FUNC_ARROW
+ {
+ mRULE_FUNC_ARROW();
+
+ }
+ break;
+ case 9 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:120: RULE_COMPARE
+ {
+ mRULE_COMPARE();
+
+ }
+ break;
+ case 10 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:133: RULE_COMPOUND_ASSIGN
+ {
+ mRULE_COMPOUND_ASSIGN();
+
+ }
+ break;
+ case 11 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:154: RULE_PLUS_PLUS
+ {
+ mRULE_PLUS_PLUS();
+
+ }
+ break;
+ case 12 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:169: RULE_MINUS_MINUS
+ {
+ mRULE_MINUS_MINUS();
+
+ }
+ break;
+ case 13 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:186: RULE_PARAM_END
+ {
+ mRULE_PARAM_END();
+
+ }
+ break;
+ case 14 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:201: RULE_PARAM_START
+ {
+ mRULE_PARAM_START();
+
+ }
+ break;
+ case 15 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:218: RULE_AT_SIGIL
+ {
+ mRULE_AT_SIGIL();
+
+ }
+ break;
+ case 16 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:232: RULE_BOOL
+ {
+ mRULE_BOOL();
+
+ }
+ break;
+ case 17 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:242: RULE_BY
+ {
+ mRULE_BY();
+
+ }
+ break;
+ case 18 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:250: RULE_CALL_END
+ {
+ mRULE_CALL_END();
+
+ }
+ break;
+ case 19 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:264: RULE_CALL_START
+ {
+ mRULE_CALL_START();
+
+ }
+ break;
+ case 20 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:280: RULE_CATCH
+ {
+ mRULE_CATCH();
+
+ }
+ break;
+ case 21 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:291: RULE_CLASS
+ {
+ mRULE_CLASS();
+
+ }
+ break;
+ case 22 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:302: RULE_COLON
+ {
+ mRULE_COLON();
+
+ }
+ break;
+ case 23 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:313: RULE_COLON_SLASH
+ {
+ mRULE_COLON_SLASH();
+
+ }
+ break;
+ case 24 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:330: RULE_COMMA
+ {
+ mRULE_COMMA();
+
+ }
+ break;
+ case 25 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:341: RULE_DOT
+ {
+ mRULE_DOT();
+
+ }
+ break;
+ case 26 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:350: RULE_ELSE
+ {
+ mRULE_ELSE();
+
+ }
+ break;
+ case 27 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:360: RULE_EQUAL
+ {
+ mRULE_EQUAL();
+
+ }
+ break;
+ case 28 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:371: RULE_EXTENDS
+ {
+ mRULE_EXTENDS();
+
+ }
+ break;
+ case 29 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:384: RULE_FINALLY
+ {
+ mRULE_FINALLY();
+
+ }
+ break;
+ case 30 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:397: RULE_FOR
+ {
+ mRULE_FOR();
+
+ }
+ break;
+ case 31 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:406: RULE_FORIN
+ {
+ mRULE_FORIN();
+
+ }
+ break;
+ case 32 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:417: RULE_FOROF
+ {
+ mRULE_FOROF();
+
+ }
+ break;
+ case 33 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:428: RULE_FUNC_EXIST
+ {
+ mRULE_FUNC_EXIST();
+
+ }
+ break;
+ case 34 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:444: RULE_HERECOMMENT
+ {
+ mRULE_HERECOMMENT();
+
+ }
+ break;
+ case 35 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:461: RULE_IF
+ {
+ mRULE_IF();
+
+ }
+ break;
+ case 36 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:469: RULE_INDENT
+ {
+ mRULE_INDENT();
+
+ }
+ break;
+ case 37 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:481: RULE_INDEX_END
+ {
+ mRULE_INDEX_END();
+
+ }
+ break;
+ case 38 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:496: RULE_INDEX_PROTO
+ {
+ mRULE_INDEX_PROTO();
+
+ }
+ break;
+ case 39 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:513: RULE_INDEX_SOAK
+ {
+ mRULE_INDEX_SOAK();
+
+ }
+ break;
+ case 40 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:529: RULE_INDEX_START
+ {
+ mRULE_INDEX_START();
+
+ }
+ break;
+ case 41 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:546: RULE_JS
+ {
+ mRULE_JS();
+
+ }
+ break;
+ case 42 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:554: RULE_LBRACKET
+ {
+ mRULE_LBRACKET();
+
+ }
+ break;
+ case 43 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:568: RULE_LCURLY
+ {
+ mRULE_LCURLY();
+
+ }
+ break;
+ case 44 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:580: RULE_LEADING_WHEN
+ {
+ mRULE_LEADING_WHEN();
+
+ }
+ break;
+ case 45 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:598: RULE_LOGIC
+ {
+ mRULE_LOGIC();
+
+ }
+ break;
+ case 46 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:609: RULE_LOOP
+ {
+ mRULE_LOOP();
+
+ }
+ break;
+ case 47 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:619: RULE_LPAREN
+ {
+ mRULE_LPAREN();
+
+ }
+ break;
+ case 48 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:631: RULE_MATH
+ {
+ mRULE_MATH();
+
+ }
+ break;
+ case 49 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:641: RULE_MINUS
+ {
+ mRULE_MINUS();
+
+ }
+ break;
+ case 50 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:652: RULE_NEW
+ {
+ mRULE_NEW();
+
+ }
+ break;
+ case 51 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:661: RULE_NUMBER
+ {
+ mRULE_NUMBER();
+
+ }
+ break;
+ case 52 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:673: RULE_OUTDENT
+ {
+ mRULE_OUTDENT();
+
+ }
+ break;
+ case 53 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:686: RULE_OWN
+ {
+ mRULE_OWN();
+
+ }
+ break;
+ case 54 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:695: RULE_PLUS
+ {
+ mRULE_PLUS();
+
+ }
+ break;
+ case 55 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:705: RULE_POST_IF
+ {
+ mRULE_POST_IF();
+
+ }
+ break;
+ case 56 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:718: RULE_QUESTION
+ {
+ mRULE_QUESTION();
+
+ }
+ break;
+ case 57 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:732: RULE_QUESTION_DOT
+ {
+ mRULE_QUESTION_DOT();
+
+ }
+ break;
+ case 58 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:750: RULE_RBRACKET
+ {
+ mRULE_RBRACKET();
+
+ }
+ break;
+ case 59 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:764: RULE_RCURLY
+ {
+ mRULE_RCURLY();
+
+ }
+ break;
+ case 60 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:776: RULE_REGEX
+ {
+ mRULE_REGEX();
+
+ }
+ break;
+ case 61 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:787: RULE_RELATION
+ {
+ mRULE_RELATION();
+
+ }
+ break;
+ case 62 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:801: RULE_RETURN
+ {
+ mRULE_RETURN();
+
+ }
+ break;
+ case 63 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:813: RULE_RPAREN
+ {
+ mRULE_RPAREN();
+
+ }
+ break;
+ case 64 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:825: RULE_STATEMENT
+ {
+ mRULE_STATEMENT();
+
+ }
+ break;
+ case 65 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:840: RULE_STRING
+ {
+ mRULE_STRING();
+
+ }
+ break;
+ case 66 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:852: RULE_SUPER
+ {
+ mRULE_SUPER();
+
+ }
+ break;
+ case 67 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:863: RULE_SWITCH
+ {
+ mRULE_SWITCH();
+
+ }
+ break;
+ case 68 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:875: RULE_TERMINATOR
+ {
+ mRULE_TERMINATOR();
+
+ }
+ break;
+ case 69 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:891: RULE_THEN
+ {
+ mRULE_THEN();
+
+ }
+ break;
+ case 70 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:901: RULE_THIS
+ {
+ mRULE_THIS();
+
+ }
+ break;
+ case 71 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:911: RULE_THROW
+ {
+ mRULE_THROW();
+
+ }
+ break;
+ case 72 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:922: RULE_TRY
+ {
+ mRULE_TRY();
+
+ }
+ break;
+ case 73 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:931: RULE_UNARY
+ {
+ mRULE_UNARY();
+
+ }
+ break;
+ case 74 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:942: RULE_UNTIL
+ {
+ mRULE_UNTIL();
+
+ }
+ break;
+ case 75 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:953: RULE_WHEN
+ {
+ mRULE_WHEN();
+
+ }
+ break;
+ case 76 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:963: RULE_WHILE
+ {
+ mRULE_WHILE();
+
+ }
+ break;
+ case 77 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:974: RULE_LOGIC_WORD
+ {
+ mRULE_LOGIC_WORD();
+
+ }
+ break;
+ case 78 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:990: RULE_COMPARE_WORD
+ {
+ mRULE_COMPARE_WORD();
+
+ }
+ break;
+ case 79 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:1008: RULE_UNARY_WORD
+ {
+ mRULE_UNARY_WORD();
+
+ }
+ break;
+ case 80 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:1024: RULE_ML_COMMENT
+ {
+ mRULE_ML_COMMENT();
+
+ }
+ break;
+ case 81 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:1040: RULE_SL_COMMENT
+ {
+ mRULE_SL_COMMENT();
+
+ }
+ break;
+ case 82 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:1056: RULE_WS
+ {
+ mRULE_WS();
+
+ }
+ break;
+ case 83 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1:1064: RULE_IDENTIFIER
+ {
+ mRULE_IDENTIFIER();
+
+ }
+ break;
+
+ }
+
+ }
+
+
+ protected DFA4 dfa4 = new DFA4(this);
+ protected DFA29 dfa29 = new DFA29(this);
+ static final String DFA4_eotS =
+ "\13\uffff";
+ static final String DFA4_eofS =
+ "\13\uffff";
+ static final String DFA4_minS =
+ "\1\146\3\uffff\1\157\1\146\5\uffff";
+ static final String DFA4_maxS =
+ "\1\171\3\uffff\1\165\1\156\5\uffff";
+ static final String DFA4_acceptS =
+ "\1\uffff\1\1\1\2\1\3\2\uffff\1\7\1\4\1\6\1\5\1\10";
+ static final String DFA4_specialS =
+ "\13\uffff}>";
+ static final String[] DFA4_transitionS = {
+ "\1\2\7\uffff\1\4\1\5\4\uffff\1\1\1\3\3\uffff\1\6",
+ "",
+ "",
+ "",
+ "\1\10\5\uffff\1\7",
+ "\1\12\7\uffff\1\11",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
+ static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
+ static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
+ static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
+ static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
+ static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
+ static final short[][] DFA4_transition;
+
+ static {
+ int numStates = DFA4_transitionS.length;
+ DFA4_transition = new short[numStates][];
+ for (int i=0; i";
+ static final String[] DFA29_transitionS = {
+ "\1\51\1\44\25\uffff\1\51\1\11\1\42\1\50\2\uffff\1\33\1\42\1"+
+ "\14\1\41\1\13\1\12\1\26\1\10\1\3\1\35\12\36\1\4\1\uffff\1\5"+
+ "\1\7\1\6\1\37\1\15\32\52\1\32\1\uffff\1\40\2\52\1\uffff\1\47"+
+ "\1\23\1\24\1\25\1\27\1\16\2\52\1\30\2\52\1\34\1\52\1\20\1\21"+
+ "\2\52\1\1\1\43\1\2\1\17\1\52\1\46\1\52\1\22\1\52\1\31\1\33\1"+
+ "\uffff\1\45",
+ "\1\53",
+ "\1\54\6\uffff\1\56\11\uffff\1\55",
+ "\1\57",
+ "\1\61",
+ "\1\63",
+ "\1\63",
+ "\1\64\1\65",
+ "\1\71\17\uffff\1\70\1\67",
+ "\1\64",
+ "\1\73\21\uffff\1\70",
+ "\1\76\1\75\62\uffff\1\77\37\uffff\1\100",
+ "\1\102",
+ "",
+ "\1\104\7\uffff\1\105\5\uffff\1\106",
+ "\1\107",
+ "\1\112\11\uffff\1\111\5\uffff\1\110",
+ "\1\114\7\uffff\1\113\3\uffff\1\116\4\uffff\1\115",
+ "\1\117",
+ "\1\121\6\uffff\1\120",
+ "\1\122\12\uffff\1\123\2\uffff\1\124",
+ "\1\126\11\uffff\1\127\5\uffff\1\125",
+ "",
+ "\1\130\13\uffff\1\131",
+ "\1\133\7\uffff\1\132\4\uffff\1\134",
+ "",
+ "\1\135",
+ "",
+ "\1\137",
+ "\1\140",
+ "",
+ "\1\141",
+ "",
+ "",
+ "",
+ "\1\143\1\uffff\1\144",
+ "",
+ "",
+ "\1\145",
+ "\1\146",
+ "\1\147",
+ "",
+ "",
+ "\1\151\2\uffff\1\152",
+ "\1\153",
+ "\1\154\3\uffff\1\155",
+ "\1\156\3\uffff\1\157\10\uffff\1\160",
+ "\1\161",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\163",
+ "",
+ "\1\165",
+ "\1\166",
+ "\1\167",
+ "\1\170\7\uffff\1\171\7\uffff\1\172",
+ "\1\173",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\23\52\1\174\6\52",
+ "\1\176",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\5\52\1\177\24\52",
+ "\1\u0081",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0083",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0085",
+ "\1\u0086",
+ "\1\u0087",
+ "\1\u0088",
+ "\1\u0089",
+ "\1\u008a",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u008c",
+ "\1\u008d",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\22\52\1\u008e\7\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\15\52\1\u0091\14"+
+ "\52",
+ "",
+ "",
+ "\1\u0093",
+ "",
+ "",
+ "",
+ "\1\u0094",
+ "\1\u0095",
+ "\1\u0096\3\uffff\1\u0097",
+ "\1\u0098",
+ "\1\u0099",
+ "",
+ "\1\u009a",
+ "\1\u009b",
+ "\1\u009c",
+ "\1\u009d",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u009f",
+ "\1\u00a0",
+ "\1\u00a1",
+ "",
+ "",
+ "",
+ "",
+ "\1\u00a2",
+ "\1\u00a3",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00a5",
+ "\1\u00a6",
+ "\1\u00a7",
+ "\1\u00a8",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\1\u00ab",
+ "\1\u00ac",
+ "\1\u00ad",
+ "\1\u00ae",
+ "\1\u00af",
+ "\1\u00b0",
+ "",
+ "\1\u00b1",
+ "\1\u00b2",
+ "\1\u00b3",
+ "",
+ "",
+ "\1\u00b4",
+ "",
+ "\1\u00b5",
+ "\1\u00b6",
+ "\1\u00b7",
+ "\1\u00b8",
+ "\1\u00b9",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\u00bc\1\u00bb\2\u00bc\1\u00ba\25\u00bc\1\uffff\uffdc\u00bc",
+ "\1\u00bd",
+ "\1\u00be",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00c2",
+ "\1\u00c3",
+ "\1\u00c4",
+ "",
+ "\1\u00c5",
+ "\1\u00c6",
+ "\1\u00c7",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "",
+ "\1\u00c8",
+ "\1\u00c9",
+ "\1\u00ca",
+ "\1\u00cb",
+ "\1\u00cc",
+ "\1\u00cd",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00cf",
+ "\1\u00d0",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00d2",
+ "\1\u00d3",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00d5",
+ "\12\u00d6\1\u00d7\ufff5\u00d6",
+ "\0\u00d6",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00d9\uffdc\u00da",
+ "\1\u00db",
+ "\1\u00dc",
+ "",
+ "",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00de",
+ "\1\u00df",
+ "\1\u00e0",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00e5",
+ "\1\u00e6",
+ "\1\u00e7",
+ "",
+ "\1\u00e8",
+ "\1\u00e9",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00eb",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\0\u00d6",
+ "\12\u00d6\1\u00d7\ufff5\u00d6",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00ed\uffdc\u00da",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00d9\uffdc\u00da",
+ "\1\u00ee",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\1\u00f0",
+ "\1\u00f1",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "",
+ "",
+ "",
+ "\1\u00f2",
+ "\1\u00f3\2\uffff\1\u00f4\1\uffff\1\u00f5\1\u00f6\1\u00f7\1"+
+ "\uffff\1\u00f8\3\uffff\1\u00f9\1\uffff\1\u00fa",
+ "\1\u00fb",
+ "\1\u00fc",
+ "\1\u00fd",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00ff\uffdc\u00da",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0102",
+ "\1\u0103",
+ "",
+ "",
+ "",
+ "\1\u0104",
+ "",
+ "\1\u0105\1\uffff\1\u0106",
+ "",
+ "",
+ "\1\u0107",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0109",
+ "",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00ff\uffdc\u00da",
+ "",
+ "",
+ "\1\u010a",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u010b",
+ "",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\1\u010c",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u010d",
+ "\1\u010e",
+ "\1\u010f",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0111",
+ "",
+ "\1\u0112\2\uffff\1\u0113",
+ "",
+ ""
+ };
+
+ static final short[] DFA29_eot = DFA.unpackEncodedString(DFA29_eotS);
+ static final short[] DFA29_eof = DFA.unpackEncodedString(DFA29_eofS);
+ static final char[] DFA29_min = DFA.unpackEncodedStringToUnsignedChars(DFA29_minS);
+ static final char[] DFA29_max = DFA.unpackEncodedStringToUnsignedChars(DFA29_maxS);
+ static final short[] DFA29_accept = DFA.unpackEncodedString(DFA29_acceptS);
+ static final short[] DFA29_special = DFA.unpackEncodedString(DFA29_specialS);
+ static final short[][] DFA29_transition;
+
+ static {
+ int numStates = DFA29_transitionS.length;
+ DFA29_transition = new short[numStates][];
+ for (int i=0; i='\u0000' && LA29_153<='\t')||(LA29_153>='\u000B' && LA29_153<='\f')||(LA29_153>='\u000E' && LA29_153<='\"')||(LA29_153>='$' && LA29_153<='\uFFFF')) ) {s = 188;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA29_186 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_186>='\u0000' && LA29_186<='\t')||(LA29_186>='\u000B' && LA29_186<='\uFFFF')) ) {s = 214;}
+
+ else if ( (LA29_186=='\n') ) {s = 215;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA29_216 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_216>='\u0000' && LA29_216<='\t')||(LA29_216>='\u000B' && LA29_216<='\uFFFF')) ) {s = 214;}
+
+ else if ( (LA29_216=='\n') ) {s = 215;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA29_215 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_215>='\u0000' && LA29_215<='\uFFFF')) ) {s = 214;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA29_218 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_218=='\r') ) {s = 216;}
+
+ else if ( (LA29_218=='\n') ) {s = 215;}
+
+ else if ( (LA29_218=='#') ) {s = 217;}
+
+ else if ( ((LA29_218>='\u0000' && LA29_218<='\t')||(LA29_218>='\u000B' && LA29_218<='\f')||(LA29_218>='\u000E' && LA29_218<='\"')||(LA29_218>='$' && LA29_218<='\uFFFF')) ) {s = 218;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA29_187 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_187>='\u0000' && LA29_187<='\uFFFF')) ) {s = 214;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA29_255 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_255=='#') ) {s = 255;}
+
+ else if ( (LA29_255=='\r') ) {s = 216;}
+
+ else if ( (LA29_255=='\n') ) {s = 215;}
+
+ else if ( ((LA29_255>='\u0000' && LA29_255<='\t')||(LA29_255>='\u000B' && LA29_255<='\f')||(LA29_255>='\u000E' && LA29_255<='\"')||(LA29_255>='$' && LA29_255<='\uFFFF')) ) {s = 218;}
+
+ else s = 214;
+
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA29_217 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_217=='#') ) {s = 237;}
+
+ else if ( (LA29_217=='\r') ) {s = 216;}
+
+ else if ( (LA29_217=='\n') ) {s = 215;}
+
+ else if ( ((LA29_217>='\u0000' && LA29_217<='\t')||(LA29_217>='\u000B' && LA29_217<='\f')||(LA29_217>='\u000E' && LA29_217<='\"')||(LA29_217>='$' && LA29_217<='\uFFFF')) ) {s = 218;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA29_188 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_188=='\r') ) {s = 216;}
+
+ else if ( (LA29_188=='\n') ) {s = 215;}
+
+ else if ( (LA29_188=='#') ) {s = 217;}
+
+ else if ( ((LA29_188>='\u0000' && LA29_188<='\t')||(LA29_188>='\u000B' && LA29_188<='\f')||(LA29_188>='\u000E' && LA29_188<='\"')||(LA29_188>='$' && LA29_188<='\uFFFF')) ) {s = 218;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA29_237 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_237=='#') ) {s = 255;}
+
+ else if ( (LA29_237=='\r') ) {s = 216;}
+
+ else if ( (LA29_237=='\n') ) {s = 215;}
+
+ else if ( ((LA29_237>='\u0000' && LA29_237<='\t')||(LA29_237>='\u000B' && LA29_237<='\f')||(LA29_237>='\u000E' && LA29_237<='\"')||(LA29_237>='$' && LA29_237<='\uFFFF')) ) {s = 218;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 29, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefileParser.java b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefileParser.java
new file mode 100644
index 0000000..674ea87
--- /dev/null
+++ b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefileParser.java
@@ -0,0 +1,52159 @@
+package csep.example.cake.ui.contentassist.antlr.internal;
+
+import java.io.InputStream;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA;
+import csep.example.cake.services.CakefileGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+@SuppressWarnings("all")
+public class InternalCakefileParser extends AbstractInternalContentAssistParser {
+ public static final String[] tokenNames = new String[] {
+ "", "", "", "", "RULE_DOT_DOT", "RULE_ELLIPSIS", "RULE_EQUAL", "RULE_COMPOUND_ASSIGN", "RULE_PLUS", "RULE_MINUS", "RULE_UNARY", "RULE_PLUS_PLUS", "RULE_MINUS_MINUS", "RULE_DOT", "RULE_QUESTION_DOT", "RULE_DOUBLE_COLON", "RULE_AT_SIGIL", "RULE_FUNC_ARROW", "RULE_BOUND_FUNC_ARROW", "RULE_TASK", "RULE_CALL_START", "RULE_COMMA", "RULE_CALL_END", "RULE_TERMINATOR", "RULE_PARAM_START", "RULE_PARAM_END", "RULE_RETURN", "RULE_POST_IF", "RULE_THROW", "RULE_CLASS", "RULE_EXTENDS", "RULE_FOR", "RULE_WHILE", "RULE_WHEN", "RULE_UNTIL", "RULE_OWN", "RULE_FOROF", "RULE_FORIN", "RULE_BY", "RULE_RBRACKET", "RULE_LBRACKET", "RULE_INDENT", "RULE_OUTDENT", "RULE_QUESTION", "RULE_SUPER", "RULE_FUNC_EXIST", "RULE_INDEX_START", "RULE_INDEX_END", "RULE_THIS", "RULE_LOOP", "RULE_TRY", "RULE_CATCH", "RULE_FINALLY", "RULE_SWITCH", "RULE_ELSE", "RULE_LEADING_WHEN", "RULE_LCURLY", "RULE_RCURLY", "RULE_COLON", "RULE_NUMBER", "RULE_STRING", "RULE_BOOL", "RULE_JS", "RULE_REGEX", "RULE_RPAREN", "RULE_LPAREN", "RULE_STATEMENT", "RULE_HERECOMMENT", "RULE_LOGIC", "RULE_COMPARE", "RULE_RELATION", "RULE_SHIFT", "RULE_MATH", "RULE_IF", "RULE_IDENTIFIER", "RULE_COLON_SLASH", "RULE_INDEX_PROTO", "RULE_INDEX_SOAK", "RULE_NEW", "RULE_THEN", "RULE_LOGIC_WORD", "RULE_COMPARE_WORD", "RULE_UNARY_WORD", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "'require'"
+ };
+ public static final int RULE_BOUND_FUNC_ARROW=18;
+ public static final int RULE_SWITCH=53;
+ public static final int RULE_THROW=28;
+ public static final int RULE_PARAM_START=24;
+ public static final int RULE_TERMINATOR=23;
+ public static final int RULE_CALL_END=22;
+ public static final int RULE_RETURN=26;
+ public static final int RULE_FOR=31;
+ public static final int RULE_BOOL=61;
+ public static final int RULE_LBRACKET=40;
+ public static final int RULE_DOUBLE_COLON=15;
+ public static final int RULE_MINUS_MINUS=12;
+ public static final int RULE_COMPARE_WORD=81;
+ public static final int EOF=-1;
+ public static final int RULE_OUTDENT=42;
+ public static final int RULE_RELATION=70;
+ public static final int RULE_REGEX=63;
+ public static final int RULE_CLASS=29;
+ public static final int RULE_WHILE=32;
+ public static final int RULE_COLON_SLASH=75;
+ public static final int RULE_FUNC_EXIST=45;
+ public static final int RULE_DOT=13;
+ public static final int RULE_POST_IF=27;
+ public static final int RULE_PLUS_PLUS=11;
+ public static final int RULE_OWN=35;
+ public static final int RULE_NUMBER=59;
+ public static final int RULE_LOOP=49;
+ public static final int RULE_LPAREN=65;
+ public static final int RULE_FUNC_ARROW=17;
+ public static final int RULE_AT_SIGIL=16;
+ public static final int RULE_SHIFT=71;
+ public static final int RULE_EXTENDS=30;
+ public static final int RULE_INDEX_END=47;
+ public static final int RULE_COMPARE=69;
+ public static final int RULE_QUESTION_DOT=14;
+ public static final int RULE_RBRACKET=39;
+ public static final int RULE_COMPOUND_ASSIGN=7;
+ public static final int RULE_SUPER=44;
+ public static final int RULE_THEN=79;
+ public static final int RULE_UNARY_WORD=82;
+ public static final int RULE_LEADING_WHEN=55;
+ public static final int RULE_TASK=19;
+ public static final int RULE_DOT_DOT=4;
+ public static final int RULE_STATEMENT=66;
+ public static final int RULE_PLUS=8;
+ public static final int RULE_BY=38;
+ public static final int RULE_INDEX_SOAK=77;
+ public static final int RULE_CATCH=51;
+ public static final int RULE_CALL_START=20;
+ public static final int RULE_INDEX_PROTO=76;
+ public static final int RULE_IDENTIFIER=74;
+ public static final int RULE_COMMA=21;
+ public static final int RULE_TRY=50;
+ public static final int RULE_JS=62;
+ public static final int RULE_EQUAL=6;
+ public static final int RULE_INDENT=41;
+ public static final int RULE_HERECOMMENT=67;
+ public static final int RULE_ELLIPSIS=5;
+ public static final int RULE_FORIN=37;
+ public static final int RULE_SL_COMMENT=84;
+ public static final int RULE_PARAM_END=25;
+ public static final int T__86=86;
+ public static final int RULE_ML_COMMENT=83;
+ public static final int RULE_WHEN=33;
+ public static final int RULE_INDEX_START=46;
+ public static final int RULE_COLON=58;
+ public static final int RULE_MINUS=9;
+ public static final int RULE_STRING=60;
+ public static final int RULE_NEW=78;
+ public static final int RULE_LOGIC_WORD=80;
+ public static final int RULE_LOGIC=68;
+ public static final int RULE_RPAREN=64;
+ public static final int RULE_WS=85;
+ public static final int RULE_FOROF=36;
+ public static final int RULE_IF=73;
+ public static final int RULE_THIS=48;
+ public static final int RULE_UNARY=10;
+ public static final int RULE_RCURLY=57;
+ public static final int RULE_ELSE=54;
+ public static final int RULE_MATH=72;
+ public static final int RULE_FINALLY=52;
+ public static final int RULE_LCURLY=56;
+ public static final int RULE_QUESTION=43;
+ public static final int RULE_UNTIL=34;
+
+ // delegates
+ // delegators
+
+
+ public InternalCakefileParser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalCakefileParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+
+ }
+
+
+ public String[] getTokenNames() { return InternalCakefileParser.tokenNames; }
+ public String getGrammarFileName() { return "../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g"; }
+
+
+
+ private CakefileGrammarAccess grammarAccess;
+
+ public void setGrammarAccess(CakefileGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+
+ @Override
+ protected Grammar getGrammar() {
+ return grammarAccess.getGrammar();
+ }
+
+ @Override
+ protected String getValueForTokenName(String tokenName) {
+ return tokenName;
+ }
+
+
+
+
+ // $ANTLR start "entryRuleCakefile"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:61:1: entryRuleCakefile : ruleCakefile EOF ;
+ public final void entryRuleCakefile() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:62:1: ( ruleCakefile EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:63:1: ruleCakefile EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCakefileRule());
+ }
+ pushFollow(FOLLOW_ruleCakefile_in_entryRuleCakefile67);
+ ruleCakefile();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCakefileRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCakefile74); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleCakefile"
+
+
+ // $ANTLR start "ruleCakefile"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:70:1: ruleCakefile : ( ( rule__Cakefile__TasksAssignment )* ) ;
+ public final void ruleCakefile() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:74:2: ( ( ( rule__Cakefile__TasksAssignment )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:75:1: ( ( rule__Cakefile__TasksAssignment )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:75:1: ( ( rule__Cakefile__TasksAssignment )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:76:1: ( rule__Cakefile__TasksAssignment )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCakefileAccess().getTasksAssignment());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:77:1: ( rule__Cakefile__TasksAssignment )*
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0==RULE_TASK) ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:77:2: rule__Cakefile__TasksAssignment
+ {
+ pushFollow(FOLLOW_rule__Cakefile__TasksAssignment_in_ruleCakefile100);
+ rule__Cakefile__TasksAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop1;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCakefileAccess().getTasksAssignment());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleCakefile"
+
+
+ // $ANTLR start "entryRuleTaskDeclaration"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:89:1: entryRuleTaskDeclaration : ruleTaskDeclaration EOF ;
+ public final void entryRuleTaskDeclaration() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:90:1: ( ruleTaskDeclaration EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:91:1: ruleTaskDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationRule());
+ }
+ pushFollow(FOLLOW_ruleTaskDeclaration_in_entryRuleTaskDeclaration128);
+ ruleTaskDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleTaskDeclaration135); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleTaskDeclaration"
+
+
+ // $ANTLR start "ruleTaskDeclaration"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:98:1: ruleTaskDeclaration : ( ( rule__TaskDeclaration__Group__0 ) ) ;
+ public final void ruleTaskDeclaration() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:102:2: ( ( ( rule__TaskDeclaration__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:103:1: ( ( rule__TaskDeclaration__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:103:1: ( ( rule__TaskDeclaration__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:104:1: ( rule__TaskDeclaration__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:105:1: ( rule__TaskDeclaration__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:105:2: rule__TaskDeclaration__Group__0
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__0_in_ruleTaskDeclaration161);
+ rule__TaskDeclaration__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleTaskDeclaration"
+
+
+ // $ANTLR start "entryRuleBody"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:119:1: entryRuleBody : ruleBody EOF ;
+ public final void entryRuleBody() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:120:1: ( ruleBody EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:121:1: ruleBody EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBodyRule());
+ }
+ pushFollow(FOLLOW_ruleBody_in_entryRuleBody190);
+ ruleBody();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBodyRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBody197); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleBody"
+
+
+ // $ANTLR start "ruleBody"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:128:1: ruleBody : ( ( rule__Body__Group__0 ) ) ;
+ public final void ruleBody() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:132:2: ( ( ( rule__Body__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:133:1: ( ( rule__Body__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:133:1: ( ( rule__Body__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:134:1: ( rule__Body__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBodyAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:135:1: ( rule__Body__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:135:2: rule__Body__Group__0
+ {
+ pushFollow(FOLLOW_rule__Body__Group__0_in_ruleBody223);
+ rule__Body__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBodyAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleBody"
+
+
+ // $ANTLR start "entryRuleLine"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:147:1: entryRuleLine : ruleLine EOF ;
+ public final void entryRuleLine() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:148:1: ( ruleLine EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:149:1: ruleLine EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLineRule());
+ }
+ pushFollow(FOLLOW_ruleLine_in_entryRuleLine250);
+ ruleLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLineRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLine257); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleLine"
+
+
+ // $ANTLR start "ruleLine"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:156:1: ruleLine : ( ( rule__Line__Alternatives ) ) ;
+ public final void ruleLine() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:160:2: ( ( ( rule__Line__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:161:1: ( ( rule__Line__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:161:1: ( ( rule__Line__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:162:1: ( rule__Line__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLineAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:163:1: ( rule__Line__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:163:2: rule__Line__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Line__Alternatives_in_ruleLine283);
+ rule__Line__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLineAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleLine"
+
+
+ // $ANTLR start "entryRuleStmt"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:175:1: entryRuleStmt : ruleStmt EOF ;
+ public final void entryRuleStmt() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:176:1: ( ruleStmt EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:177:1: ruleStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStmtRule());
+ }
+ pushFollow(FOLLOW_ruleStmt_in_entryRuleStmt310);
+ ruleStmt();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStmtRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleStmt317); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleStmt"
+
+
+ // $ANTLR start "ruleStmt"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:184:1: ruleStmt : ( ( rule__Stmt__Alternatives ) ) ;
+ public final void ruleStmt() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:188:2: ( ( ( rule__Stmt__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:189:1: ( ( rule__Stmt__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:189:1: ( ( rule__Stmt__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:190:1: ( rule__Stmt__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStmtAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:191:1: ( rule__Stmt__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:191:2: rule__Stmt__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Stmt__Alternatives_in_ruleStmt343);
+ rule__Stmt__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStmtAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleStmt"
+
+
+ // $ANTLR start "entryRuleComment"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:203:1: entryRuleComment : ruleComment EOF ;
+ public final void entryRuleComment() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:204:1: ( ruleComment EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:205:1: ruleComment EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCommentRule());
+ }
+ pushFollow(FOLLOW_ruleComment_in_entryRuleComment370);
+ ruleComment();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCommentRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleComment377); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleComment"
+
+
+ // $ANTLR start "ruleComment"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:212:1: ruleComment : ( ( rule__Comment__CommentAssignment ) ) ;
+ public final void ruleComment() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:216:2: ( ( ( rule__Comment__CommentAssignment ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:217:1: ( ( rule__Comment__CommentAssignment ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:217:1: ( ( rule__Comment__CommentAssignment ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:218:1: ( rule__Comment__CommentAssignment )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCommentAccess().getCommentAssignment());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:219:1: ( rule__Comment__CommentAssignment )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:219:2: rule__Comment__CommentAssignment
+ {
+ pushFollow(FOLLOW_rule__Comment__CommentAssignment_in_ruleComment403);
+ rule__Comment__CommentAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCommentAccess().getCommentAssignment());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleComment"
+
+
+ // $ANTLR start "entryRuleRequireStmt"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:231:1: entryRuleRequireStmt : ruleRequireStmt EOF ;
+ public final void entryRuleRequireStmt() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:232:1: ( ruleRequireStmt EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:233:1: ruleRequireStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtRule());
+ }
+ pushFollow(FOLLOW_ruleRequireStmt_in_entryRuleRequireStmt430);
+ ruleRequireStmt();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRequireStmt437); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleRequireStmt"
+
+
+ // $ANTLR start "ruleRequireStmt"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:240:1: ruleRequireStmt : ( ( rule__RequireStmt__Group__0 ) ) ;
+ public final void ruleRequireStmt() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:244:2: ( ( ( rule__RequireStmt__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:245:1: ( ( rule__RequireStmt__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:245:1: ( ( rule__RequireStmt__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:246:1: ( rule__RequireStmt__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:247:1: ( rule__RequireStmt__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:247:2: rule__RequireStmt__Group__0
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group__0_in_ruleRequireStmt463);
+ rule__RequireStmt__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleRequireStmt"
+
+
+ // $ANTLR start "entryRuleReturnStmt"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:259:1: entryRuleReturnStmt : ruleReturnStmt EOF ;
+ public final void entryRuleReturnStmt() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:260:1: ( ruleReturnStmt EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:261:1: ruleReturnStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtRule());
+ }
+ pushFollow(FOLLOW_ruleReturnStmt_in_entryRuleReturnStmt490);
+ ruleReturnStmt();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleReturnStmt497); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleReturnStmt"
+
+
+ // $ANTLR start "ruleReturnStmt"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:268:1: ruleReturnStmt : ( ( rule__ReturnStmt__Group__0 ) ) ;
+ public final void ruleReturnStmt() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:272:2: ( ( ( rule__ReturnStmt__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:273:1: ( ( rule__ReturnStmt__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:273:1: ( ( rule__ReturnStmt__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:274:1: ( rule__ReturnStmt__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:275:1: ( rule__ReturnStmt__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:275:2: rule__ReturnStmt__Group__0
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__Group__0_in_ruleReturnStmt523);
+ rule__ReturnStmt__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleReturnStmt"
+
+
+ // $ANTLR start "entryRuleThrowStmt"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:287:1: entryRuleThrowStmt : ruleThrowStmt EOF ;
+ public final void entryRuleThrowStmt() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:288:1: ( ruleThrowStmt EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:289:1: ruleThrowStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getThrowStmtRule());
+ }
+ pushFollow(FOLLOW_ruleThrowStmt_in_entryRuleThrowStmt550);
+ ruleThrowStmt();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getThrowStmtRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleThrowStmt557); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleThrowStmt"
+
+
+ // $ANTLR start "ruleThrowStmt"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:296:1: ruleThrowStmt : ( ( rule__ThrowStmt__Group__0 ) ) ;
+ public final void ruleThrowStmt() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:300:2: ( ( ( rule__ThrowStmt__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:301:1: ( ( rule__ThrowStmt__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:301:1: ( ( rule__ThrowStmt__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:302:1: ( rule__ThrowStmt__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getThrowStmtAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:303:1: ( rule__ThrowStmt__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:303:2: rule__ThrowStmt__Group__0
+ {
+ pushFollow(FOLLOW_rule__ThrowStmt__Group__0_in_ruleThrowStmt583);
+ rule__ThrowStmt__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getThrowStmtAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleThrowStmt"
+
+
+ // $ANTLR start "entryRuleSuperClass"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:315:1: entryRuleSuperClass : ruleSuperClass EOF ;
+ public final void entryRuleSuperClass() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:316:1: ( ruleSuperClass EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:317:1: ruleSuperClass EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getSuperClassRule());
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_entryRuleSuperClass610);
+ ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getSuperClassRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleSuperClass617); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleSuperClass"
+
+
+ // $ANTLR start "ruleSuperClass"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:324:1: ruleSuperClass : ( ( rule__SuperClass__Alternatives ) ) ;
+ public final void ruleSuperClass() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:328:2: ( ( ( rule__SuperClass__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:329:1: ( ( rule__SuperClass__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:329:1: ( ( rule__SuperClass__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:330:1: ( rule__SuperClass__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getSuperClassAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:331:1: ( rule__SuperClass__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:331:2: rule__SuperClass__Alternatives
+ {
+ pushFollow(FOLLOW_rule__SuperClass__Alternatives_in_ruleSuperClass643);
+ rule__SuperClass__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getSuperClassAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleSuperClass"
+
+
+ // $ANTLR start "entryRuleClassDeclaration"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:343:1: entryRuleClassDeclaration : ruleClassDeclaration EOF ;
+ public final void entryRuleClassDeclaration() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:344:1: ( ruleClassDeclaration EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:345:1: ruleClassDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationRule());
+ }
+ pushFollow(FOLLOW_ruleClassDeclaration_in_entryRuleClassDeclaration670);
+ ruleClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleClassDeclaration677); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleClassDeclaration"
+
+
+ // $ANTLR start "ruleClassDeclaration"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:352:1: ruleClassDeclaration : ( ( rule__ClassDeclaration__Group__0 ) ) ;
+ public final void ruleClassDeclaration() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:356:2: ( ( ( rule__ClassDeclaration__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:357:1: ( ( rule__ClassDeclaration__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:357:1: ( ( rule__ClassDeclaration__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:358:1: ( rule__ClassDeclaration__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:359:1: ( rule__ClassDeclaration__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:359:2: rule__ClassDeclaration__Group__0
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group__0_in_ruleClassDeclaration703);
+ rule__ClassDeclaration__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleClassDeclaration"
+
+
+ // $ANTLR start "entryRuleAssignedClassDeclaration"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:371:1: entryRuleAssignedClassDeclaration : ruleAssignedClassDeclaration EOF ;
+ public final void entryRuleAssignedClassDeclaration() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:372:1: ( ruleAssignedClassDeclaration EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:373:1: ruleAssignedClassDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ pushFollow(FOLLOW_ruleAssignedClassDeclaration_in_entryRuleAssignedClassDeclaration730);
+ ruleAssignedClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignedClassDeclaration737); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleAssignedClassDeclaration"
+
+
+ // $ANTLR start "ruleAssignedClassDeclaration"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:380:1: ruleAssignedClassDeclaration : ( ( rule__AssignedClassDeclaration__Group__0 ) ) ;
+ public final void ruleAssignedClassDeclaration() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:384:2: ( ( ( rule__AssignedClassDeclaration__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:385:1: ( ( rule__AssignedClassDeclaration__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:385:1: ( ( rule__AssignedClassDeclaration__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:386:1: ( rule__AssignedClassDeclaration__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:387:1: ( rule__AssignedClassDeclaration__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:387:2: rule__AssignedClassDeclaration__Group__0
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group__0_in_ruleAssignedClassDeclaration763);
+ rule__AssignedClassDeclaration__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleAssignedClassDeclaration"
+
+
+ // $ANTLR start "entryRuleExpression"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:399:1: entryRuleExpression : ruleExpression EOF ;
+ public final void entryRuleExpression() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:400:1: ( ruleExpression EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:401:1: ruleExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExpressionRule());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_entryRuleExpression790);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExpressionRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExpression797); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleExpression"
+
+
+ // $ANTLR start "ruleExpression"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:408:1: ruleExpression : ( rulePostfix ) ;
+ public final void ruleExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:412:2: ( ( rulePostfix ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:413:1: ( rulePostfix )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:413:1: ( rulePostfix )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:414:1: rulePostfix
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExpressionAccess().getPostfixParserRuleCall());
+ }
+ pushFollow(FOLLOW_rulePostfix_in_ruleExpression823);
+ rulePostfix();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExpressionAccess().getPostfixParserRuleCall());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleExpression"
+
+
+ // $ANTLR start "entryRulePostfix"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:427:1: entryRulePostfix : rulePostfix EOF ;
+ public final void entryRulePostfix() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:428:1: ( rulePostfix EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:429:1: rulePostfix EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixRule());
+ }
+ pushFollow(FOLLOW_rulePostfix_in_entryRulePostfix849);
+ rulePostfix();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRulePostfix856); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRulePostfix"
+
+
+ // $ANTLR start "rulePostfix"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:436:1: rulePostfix : ( ( rule__Postfix__Group__0 ) ) ;
+ public final void rulePostfix() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:440:2: ( ( ( rule__Postfix__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:441:1: ( ( rule__Postfix__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:441:1: ( ( rule__Postfix__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:442:1: ( rule__Postfix__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:443:1: ( rule__Postfix__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:443:2: rule__Postfix__Group__0
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group__0_in_rulePostfix882);
+ rule__Postfix__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rulePostfix"
+
+
+ // $ANTLR start "entryRuleForBody"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:455:1: entryRuleForBody : ruleForBody EOF ;
+ public final void entryRuleForBody() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:456:1: ( ruleForBody EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:457:1: ruleForBody EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyRule());
+ }
+ pushFollow(FOLLOW_ruleForBody_in_entryRuleForBody909);
+ ruleForBody();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleForBody916); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleForBody"
+
+
+ // $ANTLR start "ruleForBody"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:464:1: ruleForBody : ( ( rule__ForBody__Group__0 ) ) ;
+ public final void ruleForBody() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:468:2: ( ( ( rule__ForBody__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:469:1: ( ( rule__ForBody__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:469:1: ( ( rule__ForBody__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:470:1: ( rule__ForBody__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:471:1: ( rule__ForBody__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:471:2: rule__ForBody__Group__0
+ {
+ pushFollow(FOLLOW_rule__ForBody__Group__0_in_ruleForBody942);
+ rule__ForBody__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleForBody"
+
+
+ // $ANTLR start "entryRuleForValue"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:483:1: entryRuleForValue : ruleForValue EOF ;
+ public final void entryRuleForValue() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:484:1: ( ruleForValue EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:485:1: ruleForValue EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForValueRule());
+ }
+ pushFollow(FOLLOW_ruleForValue_in_entryRuleForValue969);
+ ruleForValue();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForValueRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleForValue976); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleForValue"
+
+
+ // $ANTLR start "ruleForValue"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:492:1: ruleForValue : ( ruleId ) ;
+ public final void ruleForValue() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:496:2: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:497:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:497:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:498:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForValueAccess().getIdParserRuleCall());
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleForValue1002);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForValueAccess().getIdParserRuleCall());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleForValue"
+
+
+ // $ANTLR start "entryRuleForSource"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:511:1: entryRuleForSource : ruleForSource EOF ;
+ public final void entryRuleForSource() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:512:1: ( ruleForSource EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:513:1: ruleForSource EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceRule());
+ }
+ pushFollow(FOLLOW_ruleForSource_in_entryRuleForSource1028);
+ ruleForSource();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleForSource1035); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleForSource"
+
+
+ // $ANTLR start "ruleForSource"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:520:1: ruleForSource : ( ( rule__ForSource__Group__0 ) ) ;
+ public final void ruleForSource() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:524:2: ( ( ( rule__ForSource__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:525:1: ( ( rule__ForSource__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:525:1: ( ( rule__ForSource__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:526:1: ( rule__ForSource__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:527:1: ( rule__ForSource__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:527:2: rule__ForSource__Group__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group__0_in_ruleForSource1061);
+ rule__ForSource__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleForSource"
+
+
+ // $ANTLR start "entryRuleRange"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:539:1: entryRuleRange : ruleRange EOF ;
+ public final void entryRuleRange() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:540:1: ( ruleRange EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:541:1: ruleRange EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeRule());
+ }
+ pushFollow(FOLLOW_ruleRange_in_entryRuleRange1088);
+ ruleRange();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRange1095); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleRange"
+
+
+ // $ANTLR start "ruleRange"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:548:1: ruleRange : ( ( rule__Range__Group__0 ) ) ;
+ public final void ruleRange() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:552:2: ( ( ( rule__Range__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:553:1: ( ( rule__Range__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:553:1: ( ( rule__Range__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:554:1: ( rule__Range__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:555:1: ( rule__Range__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:555:2: rule__Range__Group__0
+ {
+ pushFollow(FOLLOW_rule__Range__Group__0_in_ruleRange1121);
+ rule__Range__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleRange"
+
+
+ // $ANTLR start "entryRuleAssignment"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:567:1: entryRuleAssignment : ruleAssignment EOF ;
+ public final void entryRuleAssignment() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:568:1: ( ruleAssignment EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:569:1: ruleAssignment EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentRule());
+ }
+ pushFollow(FOLLOW_ruleAssignment_in_entryRuleAssignment1148);
+ ruleAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignment1155); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleAssignment"
+
+
+ // $ANTLR start "ruleAssignment"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:576:1: ruleAssignment : ( ( rule__Assignment__Alternatives ) ) ;
+ public final void ruleAssignment() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:580:2: ( ( ( rule__Assignment__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:581:1: ( ( rule__Assignment__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:581:1: ( ( rule__Assignment__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:582:1: ( rule__Assignment__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:583:1: ( rule__Assignment__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:583:2: rule__Assignment__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Assignment__Alternatives_in_ruleAssignment1181);
+ rule__Assignment__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleAssignment"
+
+
+ // $ANTLR start "entryRuleAssigned"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:595:1: entryRuleAssigned : ruleAssigned EOF ;
+ public final void entryRuleAssigned() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:596:1: ( ruleAssigned EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:597:1: ruleAssigned EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedRule());
+ }
+ pushFollow(FOLLOW_ruleAssigned_in_entryRuleAssigned1208);
+ ruleAssigned();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssigned1215); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleAssigned"
+
+
+ // $ANTLR start "ruleAssigned"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:604:1: ruleAssigned : ( ( rule__Assigned__Alternatives ) ) ;
+ public final void ruleAssigned() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:608:2: ( ( ( rule__Assigned__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:609:1: ( ( rule__Assigned__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:609:1: ( ( rule__Assigned__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:610:1: ( rule__Assigned__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:611:1: ( rule__Assigned__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:611:2: rule__Assigned__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Assigned__Alternatives_in_ruleAssigned1241);
+ rule__Assigned__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleAssigned"
+
+
+ // $ANTLR start "entryRuleLogicOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:623:1: entryRuleLogicOp : ruleLogicOp EOF ;
+ public final void entryRuleLogicOp() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:624:1: ( ruleLogicOp EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:625:1: ruleLogicOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpRule());
+ }
+ pushFollow(FOLLOW_ruleLogicOp_in_entryRuleLogicOp1268);
+ ruleLogicOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLogicOp1275); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleLogicOp"
+
+
+ // $ANTLR start "ruleLogicOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:632:1: ruleLogicOp : ( ( rule__LogicOp__Group__0 ) ) ;
+ public final void ruleLogicOp() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:636:2: ( ( ( rule__LogicOp__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:637:1: ( ( rule__LogicOp__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:637:1: ( ( rule__LogicOp__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:638:1: ( rule__LogicOp__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:639:1: ( rule__LogicOp__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:639:2: rule__LogicOp__Group__0
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group__0_in_ruleLogicOp1301);
+ rule__LogicOp__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleLogicOp"
+
+
+ // $ANTLR start "entryRuleCompareOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:651:1: entryRuleCompareOp : ruleCompareOp EOF ;
+ public final void entryRuleCompareOp() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:652:1: ( ruleCompareOp EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:653:1: ruleCompareOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpRule());
+ }
+ pushFollow(FOLLOW_ruleCompareOp_in_entryRuleCompareOp1328);
+ ruleCompareOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCompareOp1335); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleCompareOp"
+
+
+ // $ANTLR start "ruleCompareOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:660:1: ruleCompareOp : ( ( rule__CompareOp__Group__0 ) ) ;
+ public final void ruleCompareOp() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:664:2: ( ( ( rule__CompareOp__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:665:1: ( ( rule__CompareOp__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:665:1: ( ( rule__CompareOp__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:666:1: ( rule__CompareOp__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:667:1: ( rule__CompareOp__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:667:2: rule__CompareOp__Group__0
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group__0_in_ruleCompareOp1361);
+ rule__CompareOp__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleCompareOp"
+
+
+ // $ANTLR start "entryRuleRelationOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:679:1: entryRuleRelationOp : ruleRelationOp EOF ;
+ public final void entryRuleRelationOp() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:680:1: ( ruleRelationOp EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:681:1: ruleRelationOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpRule());
+ }
+ pushFollow(FOLLOW_ruleRelationOp_in_entryRuleRelationOp1388);
+ ruleRelationOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRelationOp1395); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleRelationOp"
+
+
+ // $ANTLR start "ruleRelationOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:688:1: ruleRelationOp : ( ( rule__RelationOp__Group__0 ) ) ;
+ public final void ruleRelationOp() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:692:2: ( ( ( rule__RelationOp__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:693:1: ( ( rule__RelationOp__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:693:1: ( ( rule__RelationOp__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:694:1: ( rule__RelationOp__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:695:1: ( rule__RelationOp__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:695:2: rule__RelationOp__Group__0
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group__0_in_ruleRelationOp1421);
+ rule__RelationOp__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleRelationOp"
+
+
+ // $ANTLR start "entryRuleShiftOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:707:1: entryRuleShiftOp : ruleShiftOp EOF ;
+ public final void entryRuleShiftOp() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:708:1: ( ruleShiftOp EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:709:1: ruleShiftOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpRule());
+ }
+ pushFollow(FOLLOW_ruleShiftOp_in_entryRuleShiftOp1448);
+ ruleShiftOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleShiftOp1455); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleShiftOp"
+
+
+ // $ANTLR start "ruleShiftOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:716:1: ruleShiftOp : ( ( rule__ShiftOp__Group__0 ) ) ;
+ public final void ruleShiftOp() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:720:2: ( ( ( rule__ShiftOp__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:721:1: ( ( rule__ShiftOp__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:721:1: ( ( rule__ShiftOp__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:722:1: ( rule__ShiftOp__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:723:1: ( rule__ShiftOp__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:723:2: rule__ShiftOp__Group__0
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group__0_in_ruleShiftOp1481);
+ rule__ShiftOp__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleShiftOp"
+
+
+ // $ANTLR start "entryRuleAdditiveOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:735:1: entryRuleAdditiveOp : ruleAdditiveOp EOF ;
+ public final void entryRuleAdditiveOp() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:736:1: ( ruleAdditiveOp EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:737:1: ruleAdditiveOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpRule());
+ }
+ pushFollow(FOLLOW_ruleAdditiveOp_in_entryRuleAdditiveOp1508);
+ ruleAdditiveOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAdditiveOp1515); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleAdditiveOp"
+
+
+ // $ANTLR start "ruleAdditiveOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:744:1: ruleAdditiveOp : ( ( rule__AdditiveOp__Group__0 ) ) ;
+ public final void ruleAdditiveOp() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:748:2: ( ( ( rule__AdditiveOp__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:749:1: ( ( rule__AdditiveOp__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:749:1: ( ( rule__AdditiveOp__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:750:1: ( rule__AdditiveOp__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:751:1: ( rule__AdditiveOp__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:751:2: rule__AdditiveOp__Group__0
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group__0_in_ruleAdditiveOp1541);
+ rule__AdditiveOp__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleAdditiveOp"
+
+
+ // $ANTLR start "entryRuleMathOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:763:1: entryRuleMathOp : ruleMathOp EOF ;
+ public final void entryRuleMathOp() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:764:1: ( ruleMathOp EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:765:1: ruleMathOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpRule());
+ }
+ pushFollow(FOLLOW_ruleMathOp_in_entryRuleMathOp1568);
+ ruleMathOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleMathOp1575); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleMathOp"
+
+
+ // $ANTLR start "ruleMathOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:772:1: ruleMathOp : ( ( rule__MathOp__Group__0 ) ) ;
+ public final void ruleMathOp() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:776:2: ( ( ( rule__MathOp__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:777:1: ( ( rule__MathOp__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:777:1: ( ( rule__MathOp__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:778:1: ( rule__MathOp__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:779:1: ( rule__MathOp__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:779:2: rule__MathOp__Group__0
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group__0_in_ruleMathOp1601);
+ rule__MathOp__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleMathOp"
+
+
+ // $ANTLR start "entryRuleUnaryOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:791:1: entryRuleUnaryOp : ruleUnaryOp EOF ;
+ public final void entryRuleUnaryOp() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:792:1: ( ruleUnaryOp EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:793:1: ruleUnaryOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpRule());
+ }
+ pushFollow(FOLLOW_ruleUnaryOp_in_entryRuleUnaryOp1628);
+ ruleUnaryOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleUnaryOp1635); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleUnaryOp"
+
+
+ // $ANTLR start "ruleUnaryOp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:800:1: ruleUnaryOp : ( ( rule__UnaryOp__Alternatives ) ) ;
+ public final void ruleUnaryOp() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:804:2: ( ( ( rule__UnaryOp__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:805:1: ( ( rule__UnaryOp__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:805:1: ( ( rule__UnaryOp__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:806:1: ( rule__UnaryOp__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:807:1: ( rule__UnaryOp__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:807:2: rule__UnaryOp__Alternatives
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Alternatives_in_ruleUnaryOp1661);
+ rule__UnaryOp__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleUnaryOp"
+
+
+ // $ANTLR start "entryRuleApplication"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:819:1: entryRuleApplication : ruleApplication EOF ;
+ public final void entryRuleApplication() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:820:1: ( ruleApplication EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:821:1: ruleApplication EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationRule());
+ }
+ pushFollow(FOLLOW_ruleApplication_in_entryRuleApplication1688);
+ ruleApplication();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleApplication1695); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleApplication"
+
+
+ // $ANTLR start "ruleApplication"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:828:1: ruleApplication : ( ( rule__Application__Alternatives ) ) ;
+ public final void ruleApplication() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:832:2: ( ( ( rule__Application__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:833:1: ( ( rule__Application__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:833:1: ( ( rule__Application__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:834:1: ( rule__Application__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:835:1: ( rule__Application__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:835:2: rule__Application__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Application__Alternatives_in_ruleApplication1721);
+ rule__Application__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleApplication"
+
+
+ // $ANTLR start "entryRuleFeatureCall"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:847:1: entryRuleFeatureCall : ruleFeatureCall EOF ;
+ public final void entryRuleFeatureCall() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:848:1: ( ruleFeatureCall EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:849:1: ruleFeatureCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallRule());
+ }
+ pushFollow(FOLLOW_ruleFeatureCall_in_entryRuleFeatureCall1748);
+ ruleFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleFeatureCall1755); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleFeatureCall"
+
+
+ // $ANTLR start "ruleFeatureCall"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:856:1: ruleFeatureCall : ( ( rule__FeatureCall__Alternatives ) ) ;
+ public final void ruleFeatureCall() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:860:2: ( ( ( rule__FeatureCall__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:861:1: ( ( rule__FeatureCall__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:861:1: ( ( rule__FeatureCall__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:862:1: ( rule__FeatureCall__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:863:1: ( rule__FeatureCall__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:863:2: rule__FeatureCall__Alternatives
+ {
+ pushFollow(FOLLOW_rule__FeatureCall__Alternatives_in_ruleFeatureCall1781);
+ rule__FeatureCall__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleFeatureCall"
+
+
+ // $ANTLR start "entryRuleFunctionCall"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:875:1: entryRuleFunctionCall : ruleFunctionCall EOF ;
+ public final void entryRuleFunctionCall() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:876:1: ( ruleFunctionCall EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:877:1: ruleFunctionCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFunctionCallRule());
+ }
+ pushFollow(FOLLOW_ruleFunctionCall_in_entryRuleFunctionCall1808);
+ ruleFunctionCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFunctionCallRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleFunctionCall1815); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleFunctionCall"
+
+
+ // $ANTLR start "ruleFunctionCall"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:884:1: ruleFunctionCall : ( ( rule__FunctionCall__Group__0 ) ) ;
+ public final void ruleFunctionCall() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:888:2: ( ( ( rule__FunctionCall__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:889:1: ( ( rule__FunctionCall__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:889:1: ( ( rule__FunctionCall__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:890:1: ( rule__FunctionCall__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFunctionCallAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:891:1: ( rule__FunctionCall__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:891:2: rule__FunctionCall__Group__0
+ {
+ pushFollow(FOLLOW_rule__FunctionCall__Group__0_in_ruleFunctionCall1841);
+ rule__FunctionCall__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFunctionCallAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleFunctionCall"
+
+
+ // $ANTLR start "entryRulePropertyAccess"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:903:1: entryRulePropertyAccess : rulePropertyAccess EOF ;
+ public final void entryRulePropertyAccess() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:904:1: ( rulePropertyAccess EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:905:1: rulePropertyAccess EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccessRule());
+ }
+ pushFollow(FOLLOW_rulePropertyAccess_in_entryRulePropertyAccess1868);
+ rulePropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccessRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRulePropertyAccess1875); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRulePropertyAccess"
+
+
+ // $ANTLR start "rulePropertyAccess"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:912:1: rulePropertyAccess : ( ( rule__PropertyAccess__Alternatives ) ) ;
+ public final void rulePropertyAccess() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:916:2: ( ( ( rule__PropertyAccess__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:917:1: ( ( rule__PropertyAccess__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:917:1: ( ( rule__PropertyAccess__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:918:1: ( rule__PropertyAccess__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccessAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:919:1: ( rule__PropertyAccess__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:919:2: rule__PropertyAccess__Alternatives
+ {
+ pushFollow(FOLLOW_rule__PropertyAccess__Alternatives_in_rulePropertyAccess1901);
+ rule__PropertyAccess__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccessAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rulePropertyAccess"
+
+
+ // $ANTLR start "entryRuleThisProperty"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:931:1: entryRuleThisProperty : ruleThisProperty EOF ;
+ public final void entryRuleThisProperty() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:932:1: ( ruleThisProperty EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:933:1: ruleThisProperty EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getThisPropertyRule());
+ }
+ pushFollow(FOLLOW_ruleThisProperty_in_entryRuleThisProperty1928);
+ ruleThisProperty();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getThisPropertyRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleThisProperty1935); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleThisProperty"
+
+
+ // $ANTLR start "ruleThisProperty"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:940:1: ruleThisProperty : ( ( rule__ThisProperty__Group__0 ) ) ;
+ public final void ruleThisProperty() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:944:2: ( ( ( rule__ThisProperty__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:945:1: ( ( rule__ThisProperty__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:945:1: ( ( rule__ThisProperty__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:946:1: ( rule__ThisProperty__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getThisPropertyAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:947:1: ( rule__ThisProperty__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:947:2: rule__ThisProperty__Group__0
+ {
+ pushFollow(FOLLOW_rule__ThisProperty__Group__0_in_ruleThisProperty1961);
+ rule__ThisProperty__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getThisPropertyAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleThisProperty"
+
+
+ // $ANTLR start "entryRuleNamedPropertyAccess"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:959:1: entryRuleNamedPropertyAccess : ruleNamedPropertyAccess EOF ;
+ public final void entryRuleNamedPropertyAccess() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:960:1: ( ruleNamedPropertyAccess EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:961:1: ruleNamedPropertyAccess EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessRule());
+ }
+ pushFollow(FOLLOW_ruleNamedPropertyAccess_in_entryRuleNamedPropertyAccess1988);
+ ruleNamedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleNamedPropertyAccess1995); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleNamedPropertyAccess"
+
+
+ // $ANTLR start "ruleNamedPropertyAccess"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:968:1: ruleNamedPropertyAccess : ( ( rule__NamedPropertyAccess__Alternatives ) ) ;
+ public final void ruleNamedPropertyAccess() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:972:2: ( ( ( rule__NamedPropertyAccess__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:973:1: ( ( rule__NamedPropertyAccess__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:973:1: ( ( rule__NamedPropertyAccess__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:974:1: ( rule__NamedPropertyAccess__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:975:1: ( rule__NamedPropertyAccess__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:975:2: rule__NamedPropertyAccess__Alternatives
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__Alternatives_in_ruleNamedPropertyAccess2021);
+ rule__NamedPropertyAccess__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleNamedPropertyAccess"
+
+
+ // $ANTLR start "entryRuleIndexedPropertyAccess"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:987:1: entryRuleIndexedPropertyAccess : ruleIndexedPropertyAccess EOF ;
+ public final void entryRuleIndexedPropertyAccess() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:988:1: ( ruleIndexedPropertyAccess EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:989:1: ruleIndexedPropertyAccess EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexedPropertyAccessRule());
+ }
+ pushFollow(FOLLOW_ruleIndexedPropertyAccess_in_entryRuleIndexedPropertyAccess2048);
+ ruleIndexedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexedPropertyAccessRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIndexedPropertyAccess2055); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleIndexedPropertyAccess"
+
+
+ // $ANTLR start "ruleIndexedPropertyAccess"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:996:1: ruleIndexedPropertyAccess : ( ( rule__IndexedPropertyAccess__Group__0 ) ) ;
+ public final void ruleIndexedPropertyAccess() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1000:2: ( ( ( rule__IndexedPropertyAccess__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1001:1: ( ( rule__IndexedPropertyAccess__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1001:1: ( ( rule__IndexedPropertyAccess__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1002:1: ( rule__IndexedPropertyAccess__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexedPropertyAccessAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1003:1: ( rule__IndexedPropertyAccess__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1003:2: rule__IndexedPropertyAccess__Group__0
+ {
+ pushFollow(FOLLOW_rule__IndexedPropertyAccess__Group__0_in_ruleIndexedPropertyAccess2081);
+ rule__IndexedPropertyAccess__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexedPropertyAccessAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleIndexedPropertyAccess"
+
+
+ // $ANTLR start "entryRuleIndex"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1015:1: entryRuleIndex : ruleIndex EOF ;
+ public final void entryRuleIndex() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1016:1: ( ruleIndex EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1017:1: ruleIndex EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexRule());
+ }
+ pushFollow(FOLLOW_ruleIndex_in_entryRuleIndex2108);
+ ruleIndex();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIndex2115); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleIndex"
+
+
+ // $ANTLR start "ruleIndex"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1024:1: ruleIndex : ( ( rule__Index__Alternatives ) ) ;
+ public final void ruleIndex() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1028:2: ( ( ( rule__Index__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1029:1: ( ( rule__Index__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1029:1: ( ( rule__Index__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1030:1: ( rule__Index__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1031:1: ( rule__Index__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1031:2: rule__Index__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Index__Alternatives_in_ruleIndex2141);
+ rule__Index__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleIndex"
+
+
+ // $ANTLR start "entryRulePrimaryExpression"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1043:1: entryRulePrimaryExpression : rulePrimaryExpression EOF ;
+ public final void entryRulePrimaryExpression() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1044:1: ( rulePrimaryExpression EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1045:1: rulePrimaryExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionRule());
+ }
+ pushFollow(FOLLOW_rulePrimaryExpression_in_entryRulePrimaryExpression2168);
+ rulePrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRulePrimaryExpression2175); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRulePrimaryExpression"
+
+
+ // $ANTLR start "rulePrimaryExpression"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1052:1: rulePrimaryExpression : ( ( rule__PrimaryExpression__Alternatives ) ) ;
+ public final void rulePrimaryExpression() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1056:2: ( ( ( rule__PrimaryExpression__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1057:1: ( ( rule__PrimaryExpression__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1057:1: ( ( rule__PrimaryExpression__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1058:1: ( rule__PrimaryExpression__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1059:1: ( rule__PrimaryExpression__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1059:2: rule__PrimaryExpression__Alternatives
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Alternatives_in_rulePrimaryExpression2201);
+ rule__PrimaryExpression__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rulePrimaryExpression"
+
+
+ // $ANTLR start "entryRuleBlock"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1071:1: entryRuleBlock : ruleBlock EOF ;
+ public final void entryRuleBlock() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1072:1: ( ruleBlock EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1073:1: ruleBlock EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBlockRule());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_entryRuleBlock2228);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBlockRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBlock2235); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleBlock"
+
+
+ // $ANTLR start "ruleBlock"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1080:1: ruleBlock : ( ( rule__Block__Group__0 ) ) ;
+ public final void ruleBlock() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1084:2: ( ( ( rule__Block__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1085:1: ( ( rule__Block__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1085:1: ( ( rule__Block__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1086:1: ( rule__Block__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBlockAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1087:1: ( rule__Block__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1087:2: rule__Block__Group__0
+ {
+ pushFollow(FOLLOW_rule__Block__Group__0_in_ruleBlock2261);
+ rule__Block__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBlockAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleBlock"
+
+
+ // $ANTLR start "entryRuleCase"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1099:1: entryRuleCase : ruleCase EOF ;
+ public final void entryRuleCase() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1100:1: ( ruleCase EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1101:1: ruleCase EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseRule());
+ }
+ pushFollow(FOLLOW_ruleCase_in_entryRuleCase2288);
+ ruleCase();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCase2295); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleCase"
+
+
+ // $ANTLR start "ruleCase"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1108:1: ruleCase : ( ( rule__Case__Group__0 ) ) ;
+ public final void ruleCase() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1112:2: ( ( ( rule__Case__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1113:1: ( ( rule__Case__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1113:1: ( ( rule__Case__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1114:1: ( rule__Case__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1115:1: ( rule__Case__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1115:2: rule__Case__Group__0
+ {
+ pushFollow(FOLLOW_rule__Case__Group__0_in_ruleCase2321);
+ rule__Case__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleCase"
+
+
+ // $ANTLR start "entryRuleIfExp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1127:1: entryRuleIfExp : ruleIfExp EOF ;
+ public final void entryRuleIfExp() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1128:1: ( ruleIfExp EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1129:1: ruleIfExp EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpRule());
+ }
+ pushFollow(FOLLOW_ruleIfExp_in_entryRuleIfExp2348);
+ ruleIfExp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIfExp2355); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleIfExp"
+
+
+ // $ANTLR start "ruleIfExp"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1136:1: ruleIfExp : ( ( rule__IfExp__Group__0 ) ) ;
+ public final void ruleIfExp() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1140:2: ( ( ( rule__IfExp__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1141:1: ( ( rule__IfExp__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1141:1: ( ( rule__IfExp__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1142:1: ( rule__IfExp__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1143:1: ( rule__IfExp__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1143:2: rule__IfExp__Group__0
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group__0_in_ruleIfExp2381);
+ rule__IfExp__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleIfExp"
+
+
+ // $ANTLR start "entryRuleCondBlock"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1155:1: entryRuleCondBlock : ruleCondBlock EOF ;
+ public final void entryRuleCondBlock() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1156:1: ( ruleCondBlock EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1157:1: ruleCondBlock EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCondBlockRule());
+ }
+ pushFollow(FOLLOW_ruleCondBlock_in_entryRuleCondBlock2408);
+ ruleCondBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCondBlockRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCondBlock2415); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleCondBlock"
+
+
+ // $ANTLR start "ruleCondBlock"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1164:1: ruleCondBlock : ( ( rule__CondBlock__Group__0 ) ) ;
+ public final void ruleCondBlock() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1168:2: ( ( ( rule__CondBlock__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1169:1: ( ( rule__CondBlock__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1169:1: ( ( rule__CondBlock__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1170:1: ( rule__CondBlock__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCondBlockAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1171:1: ( rule__CondBlock__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1171:2: rule__CondBlock__Group__0
+ {
+ pushFollow(FOLLOW_rule__CondBlock__Group__0_in_ruleCondBlock2441);
+ rule__CondBlock__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCondBlockAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleCondBlock"
+
+
+ // $ANTLR start "entryRuleIdRef"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1183:1: entryRuleIdRef : ruleIdRef EOF ;
+ public final void entryRuleIdRef() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1184:1: ( ruleIdRef EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1185:1: ruleIdRef EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdRefRule());
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_entryRuleIdRef2468);
+ ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdRefRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIdRef2475); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleIdRef"
+
+
+ // $ANTLR start "ruleIdRef"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1192:1: ruleIdRef : ( ( rule__IdRef__ValAssignment ) ) ;
+ public final void ruleIdRef() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1196:2: ( ( ( rule__IdRef__ValAssignment ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1197:1: ( ( rule__IdRef__ValAssignment ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1197:1: ( ( rule__IdRef__ValAssignment ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1198:1: ( rule__IdRef__ValAssignment )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdRefAccess().getValAssignment());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1199:1: ( rule__IdRef__ValAssignment )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1199:2: rule__IdRef__ValAssignment
+ {
+ pushFollow(FOLLOW_rule__IdRef__ValAssignment_in_ruleIdRef2501);
+ rule__IdRef__ValAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdRefAccess().getValAssignment());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleIdRef"
+
+
+ // $ANTLR start "entryRuleId"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1211:1: entryRuleId : ruleId EOF ;
+ public final void entryRuleId() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1212:1: ( ruleId EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1213:1: ruleId EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdRule());
+ }
+ pushFollow(FOLLOW_ruleId_in_entryRuleId2528);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleId2535); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleId"
+
+
+ // $ANTLR start "ruleId"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1220:1: ruleId : ( ( rule__Id__NameAssignment ) ) ;
+ public final void ruleId() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1224:2: ( ( ( rule__Id__NameAssignment ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1225:1: ( ( rule__Id__NameAssignment ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1225:1: ( ( rule__Id__NameAssignment ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1226:1: ( rule__Id__NameAssignment )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdAccess().getNameAssignment());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1227:1: ( rule__Id__NameAssignment )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1227:2: rule__Id__NameAssignment
+ {
+ pushFollow(FOLLOW_rule__Id__NameAssignment_in_ruleId2561);
+ rule__Id__NameAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdAccess().getNameAssignment());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleId"
+
+
+ // $ANTLR start "entryRuleProperty"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1239:1: entryRuleProperty : ruleProperty EOF ;
+ public final void entryRuleProperty() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1240:1: ( ruleProperty EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1241:1: ruleProperty EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyRule());
+ }
+ pushFollow(FOLLOW_ruleProperty_in_entryRuleProperty2588);
+ ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleProperty2595); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleProperty"
+
+
+ // $ANTLR start "ruleProperty"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1248:1: ruleProperty : ( ( rule__Property__Alternatives ) ) ;
+ public final void ruleProperty() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1252:2: ( ( ( rule__Property__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1253:1: ( ( rule__Property__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1253:1: ( ( rule__Property__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1254:1: ( rule__Property__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1255:1: ( rule__Property__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1255:2: rule__Property__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Property__Alternatives_in_ruleProperty2621);
+ rule__Property__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleProperty"
+
+
+ // $ANTLR start "entryRuleVariable"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1267:1: entryRuleVariable : ruleVariable EOF ;
+ public final void entryRuleVariable() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1268:1: ( ruleVariable EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1269:1: ruleVariable EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableRule());
+ }
+ pushFollow(FOLLOW_ruleVariable_in_entryRuleVariable2648);
+ ruleVariable();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleVariable2655); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleVariable"
+
+
+ // $ANTLR start "ruleVariable"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1276:1: ruleVariable : ( ( rule__Variable__Alternatives ) ) ;
+ public final void ruleVariable() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1280:2: ( ( ( rule__Variable__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1281:1: ( ( rule__Variable__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1281:1: ( ( rule__Variable__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1282:1: ( rule__Variable__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1283:1: ( rule__Variable__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1283:2: rule__Variable__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Variable__Alternatives_in_ruleVariable2681);
+ rule__Variable__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleVariable"
+
+
+ // $ANTLR start "entryRuleAssignableArray"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1295:1: entryRuleAssignableArray : ruleAssignableArray EOF ;
+ public final void entryRuleAssignableArray() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1296:1: ( ruleAssignableArray EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1297:1: ruleAssignableArray EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArrayRule());
+ }
+ pushFollow(FOLLOW_ruleAssignableArray_in_entryRuleAssignableArray2708);
+ ruleAssignableArray();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArrayRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignableArray2715); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleAssignableArray"
+
+
+ // $ANTLR start "ruleAssignableArray"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1304:1: ruleAssignableArray : ( ( rule__AssignableArray__Group__0 ) ) ;
+ public final void ruleAssignableArray() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1308:2: ( ( ( rule__AssignableArray__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1309:1: ( ( rule__AssignableArray__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1309:1: ( ( rule__AssignableArray__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1310:1: ( rule__AssignableArray__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArrayAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1311:1: ( rule__AssignableArray__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1311:2: rule__AssignableArray__Group__0
+ {
+ pushFollow(FOLLOW_rule__AssignableArray__Group__0_in_ruleAssignableArray2741);
+ rule__AssignableArray__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArrayAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleAssignableArray"
+
+
+ // $ANTLR start "entryRuleAssignableArgList"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1323:1: entryRuleAssignableArgList : ruleAssignableArgList EOF ;
+ public final void entryRuleAssignableArgList() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1324:1: ( ruleAssignableArgList EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1325:1: ruleAssignableArgList EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgListRule());
+ }
+ pushFollow(FOLLOW_ruleAssignableArgList_in_entryRuleAssignableArgList2768);
+ ruleAssignableArgList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgListRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignableArgList2775); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleAssignableArgList"
+
+
+ // $ANTLR start "ruleAssignableArgList"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1332:1: ruleAssignableArgList : ( ( rule__AssignableArgList__Group__0 ) ) ;
+ public final void ruleAssignableArgList() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1336:2: ( ( ( rule__AssignableArgList__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1337:1: ( ( rule__AssignableArgList__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1337:1: ( ( rule__AssignableArgList__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1338:1: ( rule__AssignableArgList__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgListAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1339:1: ( rule__AssignableArgList__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1339:2: rule__AssignableArgList__Group__0
+ {
+ pushFollow(FOLLOW_rule__AssignableArgList__Group__0_in_ruleAssignableArgList2801);
+ rule__AssignableArgList__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgListAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleAssignableArgList"
+
+
+ // $ANTLR start "entryRuleAssignableArg"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1351:1: entryRuleAssignableArg : ruleAssignableArg EOF ;
+ public final void entryRuleAssignableArg() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1352:1: ( ruleAssignableArg EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1353:1: ruleAssignableArg EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgRule());
+ }
+ pushFollow(FOLLOW_ruleAssignableArg_in_entryRuleAssignableArg2828);
+ ruleAssignableArg();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignableArg2835); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleAssignableArg"
+
+
+ // $ANTLR start "ruleAssignableArg"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1360:1: ruleAssignableArg : ( ( rule__AssignableArg__Group__0 ) ) ;
+ public final void ruleAssignableArg() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1364:2: ( ( ( rule__AssignableArg__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1365:1: ( ( rule__AssignableArg__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1365:1: ( ( rule__AssignableArg__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1366:1: ( rule__AssignableArg__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1367:1: ( rule__AssignableArg__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1367:2: rule__AssignableArg__Group__0
+ {
+ pushFollow(FOLLOW_rule__AssignableArg__Group__0_in_ruleAssignableArg2861);
+ rule__AssignableArg__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleAssignableArg"
+
+
+ // $ANTLR start "entryRuleAssignable"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1379:1: entryRuleAssignable : ruleAssignable EOF ;
+ public final void entryRuleAssignable() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1380:1: ( ruleAssignable EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1381:1: ruleAssignable EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableRule());
+ }
+ pushFollow(FOLLOW_ruleAssignable_in_entryRuleAssignable2888);
+ ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignable2895); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleAssignable"
+
+
+ // $ANTLR start "ruleAssignable"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1388:1: ruleAssignable : ( ( rule__Assignable__Alternatives ) ) ;
+ public final void ruleAssignable() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1392:2: ( ( ( rule__Assignable__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1393:1: ( ( rule__Assignable__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1393:1: ( ( rule__Assignable__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1394:1: ( rule__Assignable__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1395:1: ( rule__Assignable__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1395:2: rule__Assignable__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Assignable__Alternatives_in_ruleAssignable2921);
+ rule__Assignable__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleAssignable"
+
+
+ // $ANTLR start "entryRuleArg"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1407:1: entryRuleArg : ruleArg EOF ;
+ public final void entryRuleArg() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1408:1: ( ruleArg EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1409:1: ruleArg EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgRule());
+ }
+ pushFollow(FOLLOW_ruleArg_in_entryRuleArg2948);
+ ruleArg();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArg2955); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleArg"
+
+
+ // $ANTLR start "ruleArg"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1416:1: ruleArg : ( ( rule__Arg__Group__0 ) ) ;
+ public final void ruleArg() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1420:2: ( ( ( rule__Arg__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1421:1: ( ( rule__Arg__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1421:1: ( ( rule__Arg__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1422:1: ( rule__Arg__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1423:1: ( rule__Arg__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1423:2: rule__Arg__Group__0
+ {
+ pushFollow(FOLLOW_rule__Arg__Group__0_in_ruleArg2981);
+ rule__Arg__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleArg"
+
+
+ // $ANTLR start "entryRuleArgLine"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1435:1: entryRuleArgLine : ruleArgLine EOF ;
+ public final void entryRuleArgLine() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1436:1: ( ruleArgLine EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1437:1: ruleArgLine EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgLineRule());
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_entryRuleArgLine3008);
+ ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgLineRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArgLine3015); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleArgLine"
+
+
+ // $ANTLR start "ruleArgLine"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1444:1: ruleArgLine : ( ( rule__ArgLine__Group__0 ) ) ;
+ public final void ruleArgLine() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1448:2: ( ( ( rule__ArgLine__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1449:1: ( ( rule__ArgLine__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1449:1: ( ( rule__ArgLine__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1450:1: ( rule__ArgLine__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgLineAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1451:1: ( rule__ArgLine__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1451:2: rule__ArgLine__Group__0
+ {
+ pushFollow(FOLLOW_rule__ArgLine__Group__0_in_ruleArgLine3041);
+ rule__ArgLine__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgLineAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleArgLine"
+
+
+ // $ANTLR start "entryRuleExplicitArgList"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1463:1: entryRuleExplicitArgList : ruleExplicitArgList EOF ;
+ public final void entryRuleExplicitArgList() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1464:1: ( ruleExplicitArgList EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1465:1: ruleExplicitArgList EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListRule());
+ }
+ pushFollow(FOLLOW_ruleExplicitArgList_in_entryRuleExplicitArgList3068);
+ ruleExplicitArgList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExplicitArgList3075); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleExplicitArgList"
+
+
+ // $ANTLR start "ruleExplicitArgList"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1472:1: ruleExplicitArgList : ( ( rule__ExplicitArgList__Group__0 ) ) ;
+ public final void ruleExplicitArgList() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1476:2: ( ( ( rule__ExplicitArgList__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1477:1: ( ( rule__ExplicitArgList__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1477:1: ( ( rule__ExplicitArgList__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1478:1: ( rule__ExplicitArgList__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1479:1: ( rule__ExplicitArgList__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1479:2: rule__ExplicitArgList__Group__0
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group__0_in_ruleExplicitArgList3101);
+ rule__ExplicitArgList__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleExplicitArgList"
+
+
+ // $ANTLR start "entryRuleArgList"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1491:1: entryRuleArgList : ruleArgList EOF ;
+ public final void entryRuleArgList() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1492:1: ( ruleArgList EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1493:1: ruleArgList EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListRule());
+ }
+ pushFollow(FOLLOW_ruleArgList_in_entryRuleArgList3128);
+ ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArgList3135); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleArgList"
+
+
+ // $ANTLR start "ruleArgList"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1500:1: ruleArgList : ( ( rule__ArgList__Group__0 ) ) ;
+ public final void ruleArgList() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1504:2: ( ( ( rule__ArgList__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1505:1: ( ( rule__ArgList__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1505:1: ( ( rule__ArgList__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1506:1: ( rule__ArgList__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1507:1: ( rule__ArgList__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1507:2: rule__ArgList__Group__0
+ {
+ pushFollow(FOLLOW_rule__ArgList__Group__0_in_ruleArgList3161);
+ rule__ArgList__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleArgList"
+
+
+ // $ANTLR start "entryRuleArray"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1519:1: entryRuleArray : ruleArray EOF ;
+ public final void entryRuleArray() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1520:1: ( ruleArray EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1521:1: ruleArray EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArrayRule());
+ }
+ pushFollow(FOLLOW_ruleArray_in_entryRuleArray3188);
+ ruleArray();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArrayRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArray3195); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleArray"
+
+
+ // $ANTLR start "ruleArray"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1528:1: ruleArray : ( ( rule__Array__Group__0 ) ) ;
+ public final void ruleArray() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1532:2: ( ( ( rule__Array__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1533:1: ( ( rule__Array__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1533:1: ( ( rule__Array__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1534:1: ( rule__Array__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArrayAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1535:1: ( rule__Array__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1535:2: rule__Array__Group__0
+ {
+ pushFollow(FOLLOW_rule__Array__Group__0_in_ruleArray3221);
+ rule__Array__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArrayAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleArray"
+
+
+ // $ANTLR start "entryRuleDictionary"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1547:1: entryRuleDictionary : ruleDictionary EOF ;
+ public final void entryRuleDictionary() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1548:1: ( ruleDictionary EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1549:1: ruleDictionary EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictionaryRule());
+ }
+ pushFollow(FOLLOW_ruleDictionary_in_entryRuleDictionary3248);
+ ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictionaryRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictionary3255); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleDictionary"
+
+
+ // $ANTLR start "ruleDictionary"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1556:1: ruleDictionary : ( ( rule__Dictionary__Group__0 ) ) ;
+ public final void ruleDictionary() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1560:2: ( ( ( rule__Dictionary__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1561:1: ( ( rule__Dictionary__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1561:1: ( ( rule__Dictionary__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1562:1: ( rule__Dictionary__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictionaryAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1563:1: ( rule__Dictionary__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1563:2: rule__Dictionary__Group__0
+ {
+ pushFollow(FOLLOW_rule__Dictionary__Group__0_in_ruleDictionary3281);
+ rule__Dictionary__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictionaryAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleDictionary"
+
+
+ // $ANTLR start "entryRuleDictItems"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1575:1: entryRuleDictItems : ruleDictItems EOF ;
+ public final void entryRuleDictItems() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1576:1: ( ruleDictItems EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1577:1: ruleDictItems EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsRule());
+ }
+ pushFollow(FOLLOW_ruleDictItems_in_entryRuleDictItems3308);
+ ruleDictItems();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictItems3315); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleDictItems"
+
+
+ // $ANTLR start "ruleDictItems"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1584:1: ruleDictItems : ( ( rule__DictItems__Group__0 ) ) ;
+ public final void ruleDictItems() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1588:2: ( ( ( rule__DictItems__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1589:1: ( ( rule__DictItems__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1589:1: ( ( rule__DictItems__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1590:1: ( rule__DictItems__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1591:1: ( rule__DictItems__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1591:2: rule__DictItems__Group__0
+ {
+ pushFollow(FOLLOW_rule__DictItems__Group__0_in_ruleDictItems3341);
+ rule__DictItems__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleDictItems"
+
+
+ // $ANTLR start "entryRuleExplicitDictItems"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1603:1: entryRuleExplicitDictItems : ruleExplicitDictItems EOF ;
+ public final void entryRuleExplicitDictItems() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1604:1: ( ruleExplicitDictItems EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1605:1: ruleExplicitDictItems EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsRule());
+ }
+ pushFollow(FOLLOW_ruleExplicitDictItems_in_entryRuleExplicitDictItems3368);
+ ruleExplicitDictItems();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExplicitDictItems3375); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleExplicitDictItems"
+
+
+ // $ANTLR start "ruleExplicitDictItems"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1612:1: ruleExplicitDictItems : ( ( rule__ExplicitDictItems__Group__0 ) ) ;
+ public final void ruleExplicitDictItems() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1616:2: ( ( ( rule__ExplicitDictItems__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1617:1: ( ( rule__ExplicitDictItems__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1617:1: ( ( rule__ExplicitDictItems__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1618:1: ( rule__ExplicitDictItems__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1619:1: ( rule__ExplicitDictItems__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1619:2: rule__ExplicitDictItems__Group__0
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group__0_in_ruleExplicitDictItems3401);
+ rule__ExplicitDictItems__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleExplicitDictItems"
+
+
+ // $ANTLR start "entryRuleDictLine"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1631:1: entryRuleDictLine : ruleDictLine EOF ;
+ public final void entryRuleDictLine() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1632:1: ( ruleDictLine EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1633:1: ruleDictLine EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictLineRule());
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_entryRuleDictLine3428);
+ ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictLineRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictLine3435); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleDictLine"
+
+
+ // $ANTLR start "ruleDictLine"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1640:1: ruleDictLine : ( ( rule__DictLine__Group__0 ) ) ;
+ public final void ruleDictLine() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1644:2: ( ( ( rule__DictLine__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1645:1: ( ( rule__DictLine__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1645:1: ( ( rule__DictLine__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1646:1: ( rule__DictLine__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictLineAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1647:1: ( rule__DictLine__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1647:2: rule__DictLine__Group__0
+ {
+ pushFollow(FOLLOW_rule__DictLine__Group__0_in_ruleDictLine3461);
+ rule__DictLine__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictLineAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleDictLine"
+
+
+ // $ANTLR start "entryRuleDictItem"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1659:1: entryRuleDictItem : ruleDictItem EOF ;
+ public final void entryRuleDictItem() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1660:1: ( ruleDictItem EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1661:1: ruleDictItem EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemRule());
+ }
+ pushFollow(FOLLOW_ruleDictItem_in_entryRuleDictItem3488);
+ ruleDictItem();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictItem3495); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleDictItem"
+
+
+ // $ANTLR start "ruleDictItem"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1668:1: ruleDictItem : ( ( rule__DictItem__Group__0 ) ) ;
+ public final void ruleDictItem() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1672:2: ( ( ( rule__DictItem__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1673:1: ( ( rule__DictItem__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1673:1: ( ( rule__DictItem__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1674:1: ( rule__DictItem__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1675:1: ( rule__DictItem__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1675:2: rule__DictItem__Group__0
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group__0_in_ruleDictItem3521);
+ rule__DictItem__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleDictItem"
+
+
+ // $ANTLR start "entryRuleDictKey"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1687:1: entryRuleDictKey : ruleDictKey EOF ;
+ public final void entryRuleDictKey() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1688:1: ( ruleDictKey EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1689:1: ruleDictKey EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictKeyRule());
+ }
+ pushFollow(FOLLOW_ruleDictKey_in_entryRuleDictKey3548);
+ ruleDictKey();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictKeyRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictKey3555); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleDictKey"
+
+
+ // $ANTLR start "ruleDictKey"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1696:1: ruleDictKey : ( ( rule__DictKey__Alternatives ) ) ;
+ public final void ruleDictKey() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1700:2: ( ( ( rule__DictKey__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1701:1: ( ( rule__DictKey__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1701:1: ( ( rule__DictKey__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1702:1: ( rule__DictKey__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictKeyAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1703:1: ( rule__DictKey__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1703:2: rule__DictKey__Alternatives
+ {
+ pushFollow(FOLLOW_rule__DictKey__Alternatives_in_ruleDictKey3581);
+ rule__DictKey__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictKeyAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleDictKey"
+
+
+ // $ANTLR start "entryRuleLambda"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1715:1: entryRuleLambda : ruleLambda EOF ;
+ public final void entryRuleLambda() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1716:1: ( ruleLambda EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1717:1: ruleLambda EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaRule());
+ }
+ pushFollow(FOLLOW_ruleLambda_in_entryRuleLambda3608);
+ ruleLambda();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLambda3615); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleLambda"
+
+
+ // $ANTLR start "ruleLambda"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1724:1: ruleLambda : ( ( rule__Lambda__Group__0 ) ) ;
+ public final void ruleLambda() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1728:2: ( ( ( rule__Lambda__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1729:1: ( ( rule__Lambda__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1729:1: ( ( rule__Lambda__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1730:1: ( rule__Lambda__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1731:1: ( rule__Lambda__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1731:2: rule__Lambda__Group__0
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group__0_in_ruleLambda3641);
+ rule__Lambda__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleLambda"
+
+
+ // $ANTLR start "entryRuleParam"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1743:1: entryRuleParam : ruleParam EOF ;
+ public final void entryRuleParam() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1744:1: ( ruleParam EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1745:1: ruleParam EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamRule());
+ }
+ pushFollow(FOLLOW_ruleParam_in_entryRuleParam3668);
+ ruleParam();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleParam3675); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleParam"
+
+
+ // $ANTLR start "ruleParam"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1752:1: ruleParam : ( ( rule__Param__Group__0 ) ) ;
+ public final void ruleParam() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1756:2: ( ( ( rule__Param__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1757:1: ( ( rule__Param__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1757:1: ( ( rule__Param__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1758:1: ( rule__Param__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1759:1: ( rule__Param__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1759:2: rule__Param__Group__0
+ {
+ pushFollow(FOLLOW_rule__Param__Group__0_in_ruleParam3701);
+ rule__Param__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleParam"
+
+
+ // $ANTLR start "entryRuleNumberLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1771:1: entryRuleNumberLiteral : ruleNumberLiteral EOF ;
+ public final void entryRuleNumberLiteral() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1772:1: ( ruleNumberLiteral EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1773:1: ruleNumberLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleNumberLiteral_in_entryRuleNumberLiteral3728);
+ ruleNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberLiteralRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleNumberLiteral3735); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleNumberLiteral"
+
+
+ // $ANTLR start "ruleNumberLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1780:1: ruleNumberLiteral : ( ( rule__NumberLiteral__Group__0 ) ) ;
+ public final void ruleNumberLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1784:2: ( ( ( rule__NumberLiteral__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1785:1: ( ( rule__NumberLiteral__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1785:1: ( ( rule__NumberLiteral__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1786:1: ( rule__NumberLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberLiteralAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1787:1: ( rule__NumberLiteral__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1787:2: rule__NumberLiteral__Group__0
+ {
+ pushFollow(FOLLOW_rule__NumberLiteral__Group__0_in_ruleNumberLiteral3761);
+ rule__NumberLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleNumberLiteral"
+
+
+ // $ANTLR start "entryRuleStringLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1799:1: entryRuleStringLiteral : ruleStringLiteral EOF ;
+ public final void entryRuleStringLiteral() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1800:1: ( ruleStringLiteral EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1801:1: ruleStringLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStringLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_entryRuleStringLiteral3788);
+ ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStringLiteralRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleStringLiteral3795); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleStringLiteral"
+
+
+ // $ANTLR start "ruleStringLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1808:1: ruleStringLiteral : ( ( rule__StringLiteral__Group__0 ) ) ;
+ public final void ruleStringLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1812:2: ( ( ( rule__StringLiteral__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1813:1: ( ( rule__StringLiteral__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1813:1: ( ( rule__StringLiteral__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1814:1: ( rule__StringLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStringLiteralAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1815:1: ( rule__StringLiteral__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1815:2: rule__StringLiteral__Group__0
+ {
+ pushFollow(FOLLOW_rule__StringLiteral__Group__0_in_ruleStringLiteral3821);
+ rule__StringLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStringLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleStringLiteral"
+
+
+ // $ANTLR start "entryRuleBoolLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1827:1: entryRuleBoolLiteral : ruleBoolLiteral EOF ;
+ public final void entryRuleBoolLiteral() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1828:1: ( ruleBoolLiteral EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1829:1: ruleBoolLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBoolLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleBoolLiteral_in_entryRuleBoolLiteral3848);
+ ruleBoolLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBoolLiteralRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBoolLiteral3855); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleBoolLiteral"
+
+
+ // $ANTLR start "ruleBoolLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1836:1: ruleBoolLiteral : ( ( rule__BoolLiteral__Group__0 ) ) ;
+ public final void ruleBoolLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1840:2: ( ( ( rule__BoolLiteral__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1841:1: ( ( rule__BoolLiteral__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1841:1: ( ( rule__BoolLiteral__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1842:1: ( rule__BoolLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBoolLiteralAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1843:1: ( rule__BoolLiteral__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1843:2: rule__BoolLiteral__Group__0
+ {
+ pushFollow(FOLLOW_rule__BoolLiteral__Group__0_in_ruleBoolLiteral3881);
+ rule__BoolLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBoolLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleBoolLiteral"
+
+
+ // $ANTLR start "entryRuleJSLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1855:1: entryRuleJSLiteral : ruleJSLiteral EOF ;
+ public final void entryRuleJSLiteral() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1856:1: ( ruleJSLiteral EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1857:1: ruleJSLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJSLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleJSLiteral_in_entryRuleJSLiteral3908);
+ ruleJSLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJSLiteralRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleJSLiteral3915); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleJSLiteral"
+
+
+ // $ANTLR start "ruleJSLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1864:1: ruleJSLiteral : ( ( rule__JSLiteral__Group__0 ) ) ;
+ public final void ruleJSLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1868:2: ( ( ( rule__JSLiteral__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1869:1: ( ( rule__JSLiteral__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1869:1: ( ( rule__JSLiteral__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1870:1: ( rule__JSLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJSLiteralAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1871:1: ( rule__JSLiteral__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1871:2: rule__JSLiteral__Group__0
+ {
+ pushFollow(FOLLOW_rule__JSLiteral__Group__0_in_ruleJSLiteral3941);
+ rule__JSLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJSLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleJSLiteral"
+
+
+ // $ANTLR start "entryRuleRegexLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1883:1: entryRuleRegexLiteral : ruleRegexLiteral EOF ;
+ public final void entryRuleRegexLiteral() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1884:1: ( ruleRegexLiteral EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1885:1: ruleRegexLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRegexLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleRegexLiteral_in_entryRuleRegexLiteral3968);
+ ruleRegexLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRegexLiteralRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRegexLiteral3975); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleRegexLiteral"
+
+
+ // $ANTLR start "ruleRegexLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1892:1: ruleRegexLiteral : ( ( rule__RegexLiteral__Group__0 ) ) ;
+ public final void ruleRegexLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1896:2: ( ( ( rule__RegexLiteral__Group__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1897:1: ( ( rule__RegexLiteral__Group__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1897:1: ( ( rule__RegexLiteral__Group__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1898:1: ( rule__RegexLiteral__Group__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRegexLiteralAccess().getGroup());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1899:1: ( rule__RegexLiteral__Group__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1899:2: rule__RegexLiteral__Group__0
+ {
+ pushFollow(FOLLOW_rule__RegexLiteral__Group__0_in_ruleRegexLiteral4001);
+ rule__RegexLiteral__Group__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRegexLiteralAccess().getGroup());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleRegexLiteral"
+
+
+ // $ANTLR start "entryRuleLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1911:1: entryRuleLiteral : ruleLiteral EOF ;
+ public final void entryRuleLiteral() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1912:1: ( ruleLiteral EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1913:1: ruleLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleLiteral_in_entryRuleLiteral4028);
+ ruleLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLiteralRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLiteral4035); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleLiteral"
+
+
+ // $ANTLR start "ruleLiteral"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1920:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ;
+ public final void ruleLiteral() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1924:2: ( ( ( rule__Literal__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1925:1: ( ( rule__Literal__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1925:1: ( ( rule__Literal__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1926:1: ( rule__Literal__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLiteralAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1927:1: ( rule__Literal__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1927:2: rule__Literal__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Literal__Alternatives_in_ruleLiteral4061);
+ rule__Literal__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLiteralAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleLiteral"
+
+
+ // $ANTLR start "entryRuleParenthetical"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1939:1: entryRuleParenthetical : ruleParenthetical EOF ;
+ public final void entryRuleParenthetical() throws RecognitionException {
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1940:1: ( ruleParenthetical EOF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1941:1: ruleParenthetical EOF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalRule());
+ }
+ pushFollow(FOLLOW_ruleParenthetical_in_entryRuleParenthetical4088);
+ ruleParenthetical();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalRule());
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleParenthetical4095); if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+ }
+ return ;
+ }
+ // $ANTLR end "entryRuleParenthetical"
+
+
+ // $ANTLR start "ruleParenthetical"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1948:1: ruleParenthetical : ( ( rule__Parenthetical__Alternatives ) ) ;
+ public final void ruleParenthetical() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1952:2: ( ( ( rule__Parenthetical__Alternatives ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1953:1: ( ( rule__Parenthetical__Alternatives ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1953:1: ( ( rule__Parenthetical__Alternatives ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1954:1: ( rule__Parenthetical__Alternatives )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getAlternatives());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1955:1: ( rule__Parenthetical__Alternatives )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1955:2: rule__Parenthetical__Alternatives
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Alternatives_in_ruleParenthetical4121);
+ rule__Parenthetical__Alternatives();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getAlternatives());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "ruleParenthetical"
+
+
+ // $ANTLR start "rule__Line__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1968:1: rule__Line__Alternatives : ( ( ruleStmt ) | ( ruleExpression ) );
+ public final void rule__Line__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1972:1: ( ( ruleStmt ) | ( ruleExpression ) )
+ int alt2=2;
+ switch ( input.LA(1) ) {
+ case RULE_RETURN:
+ case RULE_THROW:
+ case RULE_CLASS:
+ case RULE_STATEMENT:
+ case RULE_HERECOMMENT:
+ {
+ alt2=1;
+ }
+ break;
+ case RULE_IDENTIFIER:
+ {
+ int LA2_2 = input.LA(2);
+
+ if ( (LA2_2==EOF||(LA2_2>=RULE_COMPOUND_ASSIGN && LA2_2<=RULE_MINUS)||(LA2_2>=RULE_DOT && LA2_2<=RULE_DOUBLE_COLON)||LA2_2==RULE_CALL_START||LA2_2==RULE_TERMINATOR||LA2_2==RULE_POST_IF||(LA2_2>=RULE_FOR && LA2_2<=RULE_WHILE)||LA2_2==RULE_UNTIL||(LA2_2>=RULE_OUTDENT && LA2_2<=RULE_QUESTION)||(LA2_2>=RULE_FUNC_EXIST && LA2_2<=RULE_INDEX_START)||LA2_2==RULE_RPAREN||(LA2_2>=RULE_LOGIC && LA2_2<=RULE_MATH)) ) {
+ alt2=2;
+ }
+ else if ( (LA2_2==RULE_EQUAL) ) {
+ int LA2_4 = input.LA(3);
+
+ if ( ((LA2_4>=RULE_PLUS && LA2_4<=RULE_MINUS_MINUS)||(LA2_4>=RULE_AT_SIGIL && LA2_4<=RULE_BOUND_FUNC_ARROW)||LA2_4==RULE_PARAM_START||LA2_4==RULE_CLASS||(LA2_4>=RULE_FOR && LA2_4<=RULE_WHILE)||LA2_4==RULE_UNTIL||(LA2_4>=RULE_LBRACKET && LA2_4<=RULE_INDENT)||LA2_4==RULE_SUPER||(LA2_4>=RULE_THIS && LA2_4<=RULE_TRY)||LA2_4==RULE_SWITCH||LA2_4==RULE_LCURLY||(LA2_4>=RULE_NUMBER && LA2_4<=RULE_REGEX)||LA2_4==RULE_LPAREN||(LA2_4>=RULE_IF && LA2_4<=RULE_IDENTIFIER)) ) {
+ alt2=2;
+ }
+ else if ( (LA2_4==86) ) {
+ alt2=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 4, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 2, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case RULE_PLUS:
+ case RULE_MINUS:
+ case RULE_UNARY:
+ case RULE_PLUS_PLUS:
+ case RULE_MINUS_MINUS:
+ case RULE_AT_SIGIL:
+ case RULE_FUNC_ARROW:
+ case RULE_BOUND_FUNC_ARROW:
+ case RULE_PARAM_START:
+ case RULE_FOR:
+ case RULE_WHILE:
+ case RULE_UNTIL:
+ case RULE_LBRACKET:
+ case RULE_SUPER:
+ case RULE_THIS:
+ case RULE_LOOP:
+ case RULE_TRY:
+ case RULE_SWITCH:
+ case RULE_LCURLY:
+ case RULE_NUMBER:
+ case RULE_STRING:
+ case RULE_BOOL:
+ case RULE_JS:
+ case RULE_REGEX:
+ case RULE_LPAREN:
+ case RULE_IF:
+ {
+ alt2=2;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt2) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1973:1: ( ruleStmt )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1973:1: ( ruleStmt )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1974:1: ruleStmt
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLineAccess().getStmtParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleStmt_in_rule__Line__Alternatives4158);
+ ruleStmt();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLineAccess().getStmtParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1979:6: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1979:6: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1980:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLineAccess().getExpressionParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Line__Alternatives4175);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLineAccess().getExpressionParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Line__Alternatives"
+
+
+ // $ANTLR start "rule__Stmt__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1990:1: rule__Stmt__Alternatives : ( ( ruleReturnStmt ) | ( ruleThrowStmt ) | ( ( ruleRequireStmt ) ) | ( ruleComment ) | ( ruleClassDeclaration ) | ( ( rule__Stmt__StatementAssignment_5 ) ) );
+ public final void rule__Stmt__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1994:1: ( ( ruleReturnStmt ) | ( ruleThrowStmt ) | ( ( ruleRequireStmt ) ) | ( ruleComment ) | ( ruleClassDeclaration ) | ( ( rule__Stmt__StatementAssignment_5 ) ) )
+ int alt3=6;
+ switch ( input.LA(1) ) {
+ case RULE_RETURN:
+ {
+ alt3=1;
+ }
+ break;
+ case RULE_THROW:
+ {
+ alt3=2;
+ }
+ break;
+ case RULE_IDENTIFIER:
+ {
+ alt3=3;
+ }
+ break;
+ case RULE_HERECOMMENT:
+ {
+ alt3=4;
+ }
+ break;
+ case RULE_CLASS:
+ {
+ alt3=5;
+ }
+ break;
+ case RULE_STATEMENT:
+ {
+ alt3=6;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 3, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt3) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1995:1: ( ruleReturnStmt )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1995:1: ( ruleReturnStmt )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:1996:1: ruleReturnStmt
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleReturnStmt_in_rule__Stmt__Alternatives4207);
+ ruleReturnStmt();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2001:6: ( ruleThrowStmt )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2001:6: ( ruleThrowStmt )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2002:1: ruleThrowStmt
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleThrowStmt_in_rule__Stmt__Alternatives4224);
+ ruleThrowStmt();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2007:6: ( ( ruleRequireStmt ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2007:6: ( ( ruleRequireStmt ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2008:1: ( ruleRequireStmt )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2009:1: ( ruleRequireStmt )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2009:3: ruleRequireStmt
+ {
+ pushFollow(FOLLOW_ruleRequireStmt_in_rule__Stmt__Alternatives4242);
+ ruleRequireStmt();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2013:6: ( ruleComment )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2013:6: ( ruleComment )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2014:1: ruleComment
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStmtAccess().getCommentParserRuleCall_3());
+ }
+ pushFollow(FOLLOW_ruleComment_in_rule__Stmt__Alternatives4260);
+ ruleComment();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStmtAccess().getCommentParserRuleCall_3());
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2019:6: ( ruleClassDeclaration )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2019:6: ( ruleClassDeclaration )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2020:1: ruleClassDeclaration
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4());
+ }
+ pushFollow(FOLLOW_ruleClassDeclaration_in_rule__Stmt__Alternatives4277);
+ ruleClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4());
+ }
+
+ }
+
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2025:6: ( ( rule__Stmt__StatementAssignment_5 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2025:6: ( ( rule__Stmt__StatementAssignment_5 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2026:1: ( rule__Stmt__StatementAssignment_5 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStmtAccess().getStatementAssignment_5());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2027:1: ( rule__Stmt__StatementAssignment_5 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2027:2: rule__Stmt__StatementAssignment_5
+ {
+ pushFollow(FOLLOW_rule__Stmt__StatementAssignment_5_in_rule__Stmt__Alternatives4294);
+ rule__Stmt__StatementAssignment_5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStmtAccess().getStatementAssignment_5());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Stmt__Alternatives"
+
+
+ // $ANTLR start "rule__SuperClass__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2036:1: rule__SuperClass__Alternatives : ( ( ruleIdRef ) | ( ruleProperty ) );
+ public final void rule__SuperClass__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2040:1: ( ( ruleIdRef ) | ( ruleProperty ) )
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0==RULE_IDENTIFIER) ) {
+ int LA4_1 = input.LA(2);
+
+ if ( (LA4_1==EOF||LA4_1==RULE_TERMINATOR||(LA4_1>=RULE_INDENT && LA4_1<=RULE_OUTDENT)||LA4_1==RULE_RPAREN) ) {
+ alt4=1;
+ }
+ else if ( ((LA4_1>=RULE_DOT && LA4_1<=RULE_DOUBLE_COLON)||LA4_1==RULE_INDEX_START) ) {
+ alt4=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 4, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 4, 0, input);
+
+ throw nvae;
+ }
+ switch (alt4) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2041:1: ( ruleIdRef )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2041:1: ( ruleIdRef )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2042:1: ruleIdRef
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_rule__SuperClass__Alternatives4327);
+ ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2047:6: ( ruleProperty )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2047:6: ( ruleProperty )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2048:1: ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleProperty_in_rule__SuperClass__Alternatives4344);
+ ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__SuperClass__Alternatives"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Alternatives_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2058:1: rule__ClassDeclaration__Alternatives_2 : ( ( ( rule__ClassDeclaration__BodyAssignment_2_0 ) ) | ( ( rule__ClassDeclaration__Group_2_1__0 ) ) | ( ( rule__ClassDeclaration__Group_2_2__0 ) ) );
+ public final void rule__ClassDeclaration__Alternatives_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2062:1: ( ( ( rule__ClassDeclaration__BodyAssignment_2_0 ) ) | ( ( rule__ClassDeclaration__Group_2_1__0 ) ) | ( ( rule__ClassDeclaration__Group_2_2__0 ) ) )
+ int alt5=3;
+ switch ( input.LA(1) ) {
+ case RULE_INDENT:
+ {
+ alt5=1;
+ }
+ break;
+ case RULE_EXTENDS:
+ {
+ alt5=2;
+ }
+ break;
+ case RULE_IDENTIFIER:
+ {
+ alt5=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 5, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt5) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2063:1: ( ( rule__ClassDeclaration__BodyAssignment_2_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2063:1: ( ( rule__ClassDeclaration__BodyAssignment_2_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2064:1: ( rule__ClassDeclaration__BodyAssignment_2_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2065:1: ( rule__ClassDeclaration__BodyAssignment_2_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2065:2: rule__ClassDeclaration__BodyAssignment_2_0
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__BodyAssignment_2_0_in_rule__ClassDeclaration__Alternatives_24376);
+ rule__ClassDeclaration__BodyAssignment_2_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2069:6: ( ( rule__ClassDeclaration__Group_2_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2069:6: ( ( rule__ClassDeclaration__Group_2_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2070:1: ( rule__ClassDeclaration__Group_2_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getGroup_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2071:1: ( rule__ClassDeclaration__Group_2_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2071:2: rule__ClassDeclaration__Group_2_1__0
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_1__0_in_rule__ClassDeclaration__Alternatives_24394);
+ rule__ClassDeclaration__Group_2_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getGroup_2_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2075:6: ( ( rule__ClassDeclaration__Group_2_2__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2075:6: ( ( rule__ClassDeclaration__Group_2_2__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2076:1: ( rule__ClassDeclaration__Group_2_2__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getGroup_2_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2077:1: ( rule__ClassDeclaration__Group_2_2__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2077:2: rule__ClassDeclaration__Group_2_2__0
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2__0_in_rule__ClassDeclaration__Alternatives_24412);
+ rule__ClassDeclaration__Group_2_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getGroup_2_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Alternatives_2"
+
+
+ // $ANTLR start "rule__ClassDeclaration__NameAlternatives_2_2_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2086:1: rule__ClassDeclaration__NameAlternatives_2_2_0_0 : ( ( ruleId ) | ( ruleProperty ) );
+ public final void rule__ClassDeclaration__NameAlternatives_2_2_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2090:1: ( ( ruleId ) | ( ruleProperty ) )
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0==RULE_IDENTIFIER) ) {
+ int LA6_1 = input.LA(2);
+
+ if ( (LA6_1==RULE_EXTENDS||LA6_1==RULE_INDENT) ) {
+ alt6=1;
+ }
+ else if ( ((LA6_1>=RULE_DOT && LA6_1<=RULE_DOUBLE_COLON)||LA6_1==RULE_INDEX_START) ) {
+ alt6=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 6, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 6, 0, input);
+
+ throw nvae;
+ }
+ switch (alt6) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2091:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2091:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2092:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__ClassDeclaration__NameAlternatives_2_2_0_04445);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2097:6: ( ruleProperty )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2097:6: ( ruleProperty )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2098:1: ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1());
+ }
+ pushFollow(FOLLOW_ruleProperty_in_rule__ClassDeclaration__NameAlternatives_2_2_0_04462);
+ ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__NameAlternatives_2_2_0_0"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Alternatives_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2108:1: rule__AssignedClassDeclaration__Alternatives_2 : ( ( ( rule__AssignedClassDeclaration__Group_2_0__0 ) ) | ( ( rule__AssignedClassDeclaration__Group_2_1__0 ) ) );
+ public final void rule__AssignedClassDeclaration__Alternatives_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2112:1: ( ( ( rule__AssignedClassDeclaration__Group_2_0__0 ) ) | ( ( rule__AssignedClassDeclaration__Group_2_1__0 ) ) )
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0==RULE_EXTENDS) ) {
+ alt7=1;
+ }
+ else if ( (LA7_0==RULE_IDENTIFIER) ) {
+ alt7=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 7, 0, input);
+
+ throw nvae;
+ }
+ switch (alt7) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2113:1: ( ( rule__AssignedClassDeclaration__Group_2_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2113:1: ( ( rule__AssignedClassDeclaration__Group_2_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2114:1: ( rule__AssignedClassDeclaration__Group_2_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2115:1: ( rule__AssignedClassDeclaration__Group_2_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2115:2: rule__AssignedClassDeclaration__Group_2_0__0
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_0__0_in_rule__AssignedClassDeclaration__Alternatives_24494);
+ rule__AssignedClassDeclaration__Group_2_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2119:6: ( ( rule__AssignedClassDeclaration__Group_2_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2119:6: ( ( rule__AssignedClassDeclaration__Group_2_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2120:1: ( rule__AssignedClassDeclaration__Group_2_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2121:1: ( rule__AssignedClassDeclaration__Group_2_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2121:2: rule__AssignedClassDeclaration__Group_2_1__0
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1__0_in_rule__AssignedClassDeclaration__Alternatives_24512);
+ rule__AssignedClassDeclaration__Group_2_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Alternatives_2"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2130:1: rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0 : ( ( ruleId ) | ( ruleProperty ) );
+ public final void rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2134:1: ( ( ruleId ) | ( ruleProperty ) )
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0==RULE_IDENTIFIER) ) {
+ int LA8_1 = input.LA(2);
+
+ if ( ((LA8_1>=RULE_DOT && LA8_1<=RULE_DOUBLE_COLON)||LA8_1==RULE_INDEX_START) ) {
+ alt8=2;
+ }
+ else if ( (LA8_1==RULE_EXTENDS||LA8_1==RULE_INDENT) ) {
+ alt8=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 0, input);
+
+ throw nvae;
+ }
+ switch (alt8) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2135:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2135:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2136:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__AssignedClassDeclaration__NameAlternatives_2_1_0_04545);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2141:6: ( ruleProperty )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2141:6: ( ruleProperty )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2142:1: ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1());
+ }
+ pushFollow(FOLLOW_ruleProperty_in_rule__AssignedClassDeclaration__NameAlternatives_2_1_0_04562);
+ ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0"
+
+
+ // $ANTLR start "rule__Postfix__Alternatives_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2152:1: rule__Postfix__Alternatives_1 : ( ( ( rule__Postfix__Group_1_0__0 ) ) | ( ( rule__Postfix__Group_1_1__0 ) ) | ( ( rule__Postfix__Group_1_2__0 ) ) | ( ( rule__Postfix__Group_1_3__0 ) ) );
+ public final void rule__Postfix__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2156:1: ( ( ( rule__Postfix__Group_1_0__0 ) ) | ( ( rule__Postfix__Group_1_1__0 ) ) | ( ( rule__Postfix__Group_1_2__0 ) ) | ( ( rule__Postfix__Group_1_3__0 ) ) )
+ int alt9=4;
+ switch ( input.LA(1) ) {
+ case RULE_POST_IF:
+ {
+ alt9=1;
+ }
+ break;
+ case RULE_FOR:
+ {
+ alt9=2;
+ }
+ break;
+ case RULE_WHILE:
+ {
+ alt9=3;
+ }
+ break;
+ case RULE_UNTIL:
+ {
+ alt9=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt9) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2157:1: ( ( rule__Postfix__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2157:1: ( ( rule__Postfix__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2158:1: ( rule__Postfix__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2159:1: ( rule__Postfix__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2159:2: rule__Postfix__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_0__0_in_rule__Postfix__Alternatives_14594);
+ rule__Postfix__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2163:6: ( ( rule__Postfix__Group_1_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2163:6: ( ( rule__Postfix__Group_1_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2164:1: ( rule__Postfix__Group_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getGroup_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2165:1: ( rule__Postfix__Group_1_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2165:2: rule__Postfix__Group_1_1__0
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_1__0_in_rule__Postfix__Alternatives_14612);
+ rule__Postfix__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2169:6: ( ( rule__Postfix__Group_1_2__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2169:6: ( ( rule__Postfix__Group_1_2__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2170:1: ( rule__Postfix__Group_1_2__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getGroup_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2171:1: ( rule__Postfix__Group_1_2__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2171:2: rule__Postfix__Group_1_2__0
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2__0_in_rule__Postfix__Alternatives_14630);
+ rule__Postfix__Group_1_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getGroup_1_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2175:6: ( ( rule__Postfix__Group_1_3__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2175:6: ( ( rule__Postfix__Group_1_3__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2176:1: ( rule__Postfix__Group_1_3__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getGroup_1_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2177:1: ( rule__Postfix__Group_1_3__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2177:2: rule__Postfix__Group_1_3__0
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3__0_in_rule__Postfix__Alternatives_14648);
+ rule__Postfix__Group_1_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getGroup_1_3());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Alternatives_1"
+
+
+ // $ANTLR start "rule__ForSource__Alternatives_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2186:1: rule__ForSource__Alternatives_1 : ( ( ( rule__ForSource__Group_1_0__0 ) ) | ( ( rule__ForSource__Group_1_1__0 ) ) );
+ public final void rule__ForSource__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2190:1: ( ( ( rule__ForSource__Group_1_0__0 ) ) | ( ( rule__ForSource__Group_1_1__0 ) ) )
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0==RULE_FOROF) ) {
+ alt10=1;
+ }
+ else if ( (LA10_0==RULE_FORIN) ) {
+ alt10=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 10, 0, input);
+
+ throw nvae;
+ }
+ switch (alt10) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2191:1: ( ( rule__ForSource__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2191:1: ( ( rule__ForSource__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2192:1: ( rule__ForSource__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2193:1: ( rule__ForSource__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2193:2: rule__ForSource__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0__0_in_rule__ForSource__Alternatives_14681);
+ rule__ForSource__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2197:6: ( ( rule__ForSource__Group_1_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2197:6: ( ( rule__ForSource__Group_1_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2198:1: ( rule__ForSource__Group_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getGroup_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2199:1: ( rule__ForSource__Group_1_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2199:2: rule__ForSource__Group_1_1__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1__0_in_rule__ForSource__Alternatives_14699);
+ rule__ForSource__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Alternatives_1"
+
+
+ // $ANTLR start "rule__ForSource__Alternatives_1_1_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2208:1: rule__ForSource__Alternatives_1_1_2 : ( ( ( rule__ForSource__Group_1_1_2_0__0 ) ) | ( ( rule__ForSource__Group_1_1_2_1__0 ) ) );
+ public final void rule__ForSource__Alternatives_1_1_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2212:1: ( ( ( rule__ForSource__Group_1_1_2_0__0 ) ) | ( ( rule__ForSource__Group_1_1_2_1__0 ) ) )
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0==RULE_WHEN) ) {
+ alt11=1;
+ }
+ else if ( (LA11_0==RULE_BY) ) {
+ alt11=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 0, input);
+
+ throw nvae;
+ }
+ switch (alt11) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2213:1: ( ( rule__ForSource__Group_1_1_2_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2213:1: ( ( rule__ForSource__Group_1_1_2_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2214:1: ( rule__ForSource__Group_1_1_2_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getGroup_1_1_2_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2215:1: ( rule__ForSource__Group_1_1_2_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2215:2: rule__ForSource__Group_1_1_2_0__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0__0_in_rule__ForSource__Alternatives_1_1_24732);
+ rule__ForSource__Group_1_1_2_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getGroup_1_1_2_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2219:6: ( ( rule__ForSource__Group_1_1_2_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2219:6: ( ( rule__ForSource__Group_1_1_2_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2220:1: ( rule__ForSource__Group_1_1_2_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getGroup_1_1_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2221:1: ( rule__ForSource__Group_1_1_2_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2221:2: rule__ForSource__Group_1_1_2_1__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1__0_in_rule__ForSource__Alternatives_1_1_24750);
+ rule__ForSource__Group_1_1_2_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getGroup_1_1_2_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Alternatives_1_1_2"
+
+
+ // $ANTLR start "rule__Range__Alternatives_0_0_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2230:1: rule__Range__Alternatives_0_0_2 : ( ( RULE_DOT_DOT ) | ( RULE_ELLIPSIS ) );
+ public final void rule__Range__Alternatives_0_0_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2234:1: ( ( RULE_DOT_DOT ) | ( RULE_ELLIPSIS ) )
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0==RULE_DOT_DOT) ) {
+ alt12=1;
+ }
+ else if ( (LA12_0==RULE_ELLIPSIS) ) {
+ alt12=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 12, 0, input);
+
+ throw nvae;
+ }
+ switch (alt12) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2235:1: ( RULE_DOT_DOT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2235:1: ( RULE_DOT_DOT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2236:1: RULE_DOT_DOT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0());
+ }
+ match(input,RULE_DOT_DOT,FOLLOW_RULE_DOT_DOT_in_rule__Range__Alternatives_0_0_24783); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2241:6: ( RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2241:6: ( RULE_ELLIPSIS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2242:1: RULE_ELLIPSIS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getELLIPSISTerminalRuleCall_0_0_2_1());
+ }
+ match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_rule__Range__Alternatives_0_0_24800); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getELLIPSISTerminalRuleCall_0_0_2_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Alternatives_0_0_2"
+
+
+ // $ANTLR start "rule__Assignment__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2252:1: rule__Assignment__Alternatives : ( ( ( rule__Assignment__Group_0__0 ) ) | ( ruleLogicOp ) );
+ public final void rule__Assignment__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2256:1: ( ( ( rule__Assignment__Group_0__0 ) ) | ( ruleLogicOp ) )
+ int alt13=2;
+ alt13 = dfa13.predict(input);
+ switch (alt13) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2257:1: ( ( rule__Assignment__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2257:1: ( ( rule__Assignment__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2258:1: ( rule__Assignment__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2259:1: ( rule__Assignment__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2259:2: rule__Assignment__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__Assignment__Group_0__0_in_rule__Assignment__Alternatives4832);
+ rule__Assignment__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2263:6: ( ruleLogicOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2263:6: ( ruleLogicOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2264:1: ruleLogicOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleLogicOp_in_rule__Assignment__Alternatives4850);
+ ruleLogicOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Alternatives"
+
+
+ // $ANTLR start "rule__Assignment__OperatorAlternatives_0_0_0_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2274:1: rule__Assignment__OperatorAlternatives_0_0_0_1_0 : ( ( RULE_EQUAL ) | ( RULE_COMPOUND_ASSIGN ) );
+ public final void rule__Assignment__OperatorAlternatives_0_0_0_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2278:1: ( ( RULE_EQUAL ) | ( RULE_COMPOUND_ASSIGN ) )
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0==RULE_EQUAL) ) {
+ alt14=1;
+ }
+ else if ( (LA14_0==RULE_COMPOUND_ASSIGN) ) {
+ alt14=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 14, 0, input);
+
+ throw nvae;
+ }
+ switch (alt14) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2279:1: ( RULE_EQUAL )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2279:1: ( RULE_EQUAL )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2280:1: RULE_EQUAL
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0());
+ }
+ match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_rule__Assignment__OperatorAlternatives_0_0_0_1_04882); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2285:6: ( RULE_COMPOUND_ASSIGN )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2285:6: ( RULE_COMPOUND_ASSIGN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2286:1: RULE_COMPOUND_ASSIGN
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1());
+ }
+ match(input,RULE_COMPOUND_ASSIGN,FOLLOW_RULE_COMPOUND_ASSIGN_in_rule__Assignment__OperatorAlternatives_0_0_0_1_04899); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__OperatorAlternatives_0_0_0_1_0"
+
+
+ // $ANTLR start "rule__Assigned__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2296:1: rule__Assigned__Alternatives : ( ( ruleExpression ) | ( ( rule__Assigned__Group_1__0 ) ) | ( ruleAssignedClassDeclaration ) );
+ public final void rule__Assigned__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2300:1: ( ( ruleExpression ) | ( ( rule__Assigned__Group_1__0 ) ) | ( ruleAssignedClassDeclaration ) )
+ int alt15=3;
+ switch ( input.LA(1) ) {
+ case RULE_PLUS:
+ case RULE_MINUS:
+ case RULE_UNARY:
+ case RULE_PLUS_PLUS:
+ case RULE_MINUS_MINUS:
+ case RULE_AT_SIGIL:
+ case RULE_FUNC_ARROW:
+ case RULE_BOUND_FUNC_ARROW:
+ case RULE_PARAM_START:
+ case RULE_FOR:
+ case RULE_WHILE:
+ case RULE_UNTIL:
+ case RULE_LBRACKET:
+ case RULE_SUPER:
+ case RULE_THIS:
+ case RULE_LOOP:
+ case RULE_TRY:
+ case RULE_SWITCH:
+ case RULE_LCURLY:
+ case RULE_NUMBER:
+ case RULE_STRING:
+ case RULE_BOOL:
+ case RULE_JS:
+ case RULE_REGEX:
+ case RULE_LPAREN:
+ case RULE_IF:
+ case RULE_IDENTIFIER:
+ {
+ alt15=1;
+ }
+ break;
+ case RULE_INDENT:
+ {
+ alt15=2;
+ }
+ break;
+ case RULE_CLASS:
+ {
+ alt15=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 15, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt15) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2301:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2301:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2302:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Assigned__Alternatives4931);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2307:6: ( ( rule__Assigned__Group_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2307:6: ( ( rule__Assigned__Group_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2308:1: ( rule__Assigned__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2309:1: ( rule__Assigned__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2309:2: rule__Assigned__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__Assigned__Group_1__0_in_rule__Assigned__Alternatives4948);
+ rule__Assigned__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2313:6: ( ruleAssignedClassDeclaration )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2313:6: ( ruleAssignedClassDeclaration )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2314:1: ruleAssignedClassDeclaration
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2());
+ }
+ pushFollow(FOLLOW_ruleAssignedClassDeclaration_in_rule__Assigned__Alternatives4966);
+ ruleAssignedClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assigned__Alternatives"
+
+
+ // $ANTLR start "rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2324:1: rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0 : ( ( RULE_PLUS ) | ( RULE_MINUS ) );
+ public final void rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2328:1: ( ( RULE_PLUS ) | ( RULE_MINUS ) )
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0==RULE_PLUS) ) {
+ alt16=1;
+ }
+ else if ( (LA16_0==RULE_MINUS) ) {
+ alt16=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 16, 0, input);
+
+ throw nvae;
+ }
+ switch (alt16) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2329:1: ( RULE_PLUS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2329:1: ( RULE_PLUS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2330:1: RULE_PLUS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0());
+ }
+ match(input,RULE_PLUS,FOLLOW_RULE_PLUS_in_rule__AdditiveOp__OperatorAlternatives_1_0_0_1_04998); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2335:6: ( RULE_MINUS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2335:6: ( RULE_MINUS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2336:1: RULE_MINUS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1());
+ }
+ match(input,RULE_MINUS,FOLLOW_RULE_MINUS_in_rule__AdditiveOp__OperatorAlternatives_1_0_0_1_05015); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0"
+
+
+ // $ANTLR start "rule__UnaryOp__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2346:1: rule__UnaryOp__Alternatives : ( ( ( rule__UnaryOp__Group_0__0 ) ) | ( ( rule__UnaryOp__Group_1__0 ) ) | ( ( rule__UnaryOp__Group_2__0 ) ) );
+ public final void rule__UnaryOp__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2350:1: ( ( ( rule__UnaryOp__Group_0__0 ) ) | ( ( rule__UnaryOp__Group_1__0 ) ) | ( ( rule__UnaryOp__Group_2__0 ) ) )
+ int alt17=3;
+ switch ( input.LA(1) ) {
+ case RULE_PLUS:
+ case RULE_MINUS:
+ case RULE_UNARY:
+ {
+ alt17=1;
+ }
+ break;
+ case RULE_PLUS_PLUS:
+ case RULE_MINUS_MINUS:
+ {
+ alt17=2;
+ }
+ break;
+ case RULE_AT_SIGIL:
+ case RULE_FUNC_ARROW:
+ case RULE_BOUND_FUNC_ARROW:
+ case RULE_PARAM_START:
+ case RULE_FOR:
+ case RULE_WHILE:
+ case RULE_UNTIL:
+ case RULE_LBRACKET:
+ case RULE_SUPER:
+ case RULE_THIS:
+ case RULE_LOOP:
+ case RULE_TRY:
+ case RULE_SWITCH:
+ case RULE_LCURLY:
+ case RULE_NUMBER:
+ case RULE_STRING:
+ case RULE_BOOL:
+ case RULE_JS:
+ case RULE_REGEX:
+ case RULE_LPAREN:
+ case RULE_IF:
+ case RULE_IDENTIFIER:
+ {
+ alt17=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt17) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2351:1: ( ( rule__UnaryOp__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2351:1: ( ( rule__UnaryOp__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2352:1: ( rule__UnaryOp__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2353:1: ( rule__UnaryOp__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2353:2: rule__UnaryOp__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Group_0__0_in_rule__UnaryOp__Alternatives5047);
+ rule__UnaryOp__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2357:6: ( ( rule__UnaryOp__Group_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2357:6: ( ( rule__UnaryOp__Group_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2358:1: ( rule__UnaryOp__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2359:1: ( rule__UnaryOp__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2359:2: rule__UnaryOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Group_1__0_in_rule__UnaryOp__Alternatives5065);
+ rule__UnaryOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2363:6: ( ( rule__UnaryOp__Group_2__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2363:6: ( ( rule__UnaryOp__Group_2__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2364:1: ( rule__UnaryOp__Group_2__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getGroup_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2365:1: ( rule__UnaryOp__Group_2__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2365:2: rule__UnaryOp__Group_2__0
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Group_2__0_in_rule__UnaryOp__Alternatives5083);
+ rule__UnaryOp__Group_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getGroup_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Alternatives"
+
+
+ // $ANTLR start "rule__UnaryOp__Alternatives_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2374:1: rule__UnaryOp__Alternatives_0_0 : ( ( RULE_UNARY ) | ( RULE_PLUS ) | ( RULE_MINUS ) );
+ public final void rule__UnaryOp__Alternatives_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2378:1: ( ( RULE_UNARY ) | ( RULE_PLUS ) | ( RULE_MINUS ) )
+ int alt18=3;
+ switch ( input.LA(1) ) {
+ case RULE_UNARY:
+ {
+ alt18=1;
+ }
+ break;
+ case RULE_PLUS:
+ {
+ alt18=2;
+ }
+ break;
+ case RULE_MINUS:
+ {
+ alt18=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 18, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt18) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2379:1: ( RULE_UNARY )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2379:1: ( RULE_UNARY )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2380:1: RULE_UNARY
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0());
+ }
+ match(input,RULE_UNARY,FOLLOW_RULE_UNARY_in_rule__UnaryOp__Alternatives_0_05116); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2385:6: ( RULE_PLUS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2385:6: ( RULE_PLUS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2386:1: RULE_PLUS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getPLUSTerminalRuleCall_0_0_1());
+ }
+ match(input,RULE_PLUS,FOLLOW_RULE_PLUS_in_rule__UnaryOp__Alternatives_0_05133); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getPLUSTerminalRuleCall_0_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2391:6: ( RULE_MINUS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2391:6: ( RULE_MINUS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2392:1: RULE_MINUS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getMINUSTerminalRuleCall_0_0_2());
+ }
+ match(input,RULE_MINUS,FOLLOW_RULE_MINUS_in_rule__UnaryOp__Alternatives_0_05150); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getMINUSTerminalRuleCall_0_0_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Alternatives_0_0"
+
+
+ // $ANTLR start "rule__UnaryOp__Alternatives_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2402:1: rule__UnaryOp__Alternatives_1_0 : ( ( RULE_PLUS_PLUS ) | ( RULE_MINUS_MINUS ) );
+ public final void rule__UnaryOp__Alternatives_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2406:1: ( ( RULE_PLUS_PLUS ) | ( RULE_MINUS_MINUS ) )
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0==RULE_PLUS_PLUS) ) {
+ alt19=1;
+ }
+ else if ( (LA19_0==RULE_MINUS_MINUS) ) {
+ alt19=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 19, 0, input);
+
+ throw nvae;
+ }
+ switch (alt19) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2407:1: ( RULE_PLUS_PLUS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2407:1: ( RULE_PLUS_PLUS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2408:1: RULE_PLUS_PLUS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0());
+ }
+ match(input,RULE_PLUS_PLUS,FOLLOW_RULE_PLUS_PLUS_in_rule__UnaryOp__Alternatives_1_05182); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2413:6: ( RULE_MINUS_MINUS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2413:6: ( RULE_MINUS_MINUS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2414:1: RULE_MINUS_MINUS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getMINUS_MINUSTerminalRuleCall_1_0_1());
+ }
+ match(input,RULE_MINUS_MINUS,FOLLOW_RULE_MINUS_MINUS_in_rule__UnaryOp__Alternatives_1_05199); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getMINUS_MINUSTerminalRuleCall_1_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Alternatives_1_0"
+
+
+ // $ANTLR start "rule__Application__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2424:1: rule__Application__Alternatives : ( ( ( rule__Application__Group_0__0 ) ) | ( ( rule__Application__Group_1__0 ) ) );
+ public final void rule__Application__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2428:1: ( ( ( rule__Application__Group_0__0 ) ) | ( ( rule__Application__Group_1__0 ) ) )
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0==RULE_SUPER) ) {
+ alt20=1;
+ }
+ else if ( ((LA20_0>=RULE_AT_SIGIL && LA20_0<=RULE_BOUND_FUNC_ARROW)||LA20_0==RULE_PARAM_START||(LA20_0>=RULE_FOR && LA20_0<=RULE_WHILE)||LA20_0==RULE_UNTIL||LA20_0==RULE_LBRACKET||(LA20_0>=RULE_THIS && LA20_0<=RULE_TRY)||LA20_0==RULE_SWITCH||LA20_0==RULE_LCURLY||(LA20_0>=RULE_NUMBER && LA20_0<=RULE_REGEX)||LA20_0==RULE_LPAREN||(LA20_0>=RULE_IF && LA20_0<=RULE_IDENTIFIER)) ) {
+ alt20=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 20, 0, input);
+
+ throw nvae;
+ }
+ switch (alt20) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2429:1: ( ( rule__Application__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2429:1: ( ( rule__Application__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2430:1: ( rule__Application__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2431:1: ( rule__Application__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2431:2: rule__Application__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0__0_in_rule__Application__Alternatives5231);
+ rule__Application__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2435:6: ( ( rule__Application__Group_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2435:6: ( ( rule__Application__Group_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2436:1: ( rule__Application__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2437:1: ( rule__Application__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2437:2: rule__Application__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__Application__Group_1__0_in_rule__Application__Alternatives5249);
+ rule__Application__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Alternatives"
+
+
+ // $ANTLR start "rule__FeatureCall__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2446:1: rule__FeatureCall__Alternatives : ( ( ruleFunctionCall ) | ( rulePropertyAccess ) );
+ public final void rule__FeatureCall__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2450:1: ( ( ruleFunctionCall ) | ( rulePropertyAccess ) )
+ int alt21=2;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0==RULE_CALL_START||LA21_0==RULE_FUNC_EXIST) ) {
+ alt21=1;
+ }
+ else if ( ((LA21_0>=RULE_DOT && LA21_0<=RULE_DOUBLE_COLON)||LA21_0==RULE_INDEX_START) ) {
+ alt21=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 0, input);
+
+ throw nvae;
+ }
+ switch (alt21) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2451:1: ( ruleFunctionCall )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2451:1: ( ruleFunctionCall )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2452:1: ruleFunctionCall
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleFunctionCall_in_rule__FeatureCall__Alternatives5282);
+ ruleFunctionCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2457:6: ( rulePropertyAccess )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2457:6: ( rulePropertyAccess )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2458:1: rulePropertyAccess
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_rulePropertyAccess_in_rule__FeatureCall__Alternatives5299);
+ rulePropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FeatureCall__Alternatives"
+
+
+ // $ANTLR start "rule__PropertyAccess__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2468:1: rule__PropertyAccess__Alternatives : ( ( ruleNamedPropertyAccess ) | ( ruleIndexedPropertyAccess ) );
+ public final void rule__PropertyAccess__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2472:1: ( ( ruleNamedPropertyAccess ) | ( ruleIndexedPropertyAccess ) )
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( ((LA22_0>=RULE_DOT && LA22_0<=RULE_DOUBLE_COLON)) ) {
+ alt22=1;
+ }
+ else if ( (LA22_0==RULE_INDEX_START) ) {
+ alt22=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 22, 0, input);
+
+ throw nvae;
+ }
+ switch (alt22) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2473:1: ( ruleNamedPropertyAccess )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2473:1: ( ruleNamedPropertyAccess )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2474:1: ruleNamedPropertyAccess
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleNamedPropertyAccess_in_rule__PropertyAccess__Alternatives5331);
+ ruleNamedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2479:6: ( ruleIndexedPropertyAccess )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2479:6: ( ruleIndexedPropertyAccess )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2480:1: ruleIndexedPropertyAccess
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleIndexedPropertyAccess_in_rule__PropertyAccess__Alternatives5348);
+ ruleIndexedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PropertyAccess__Alternatives"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2490:1: rule__NamedPropertyAccess__Alternatives : ( ( ( rule__NamedPropertyAccess__Group_0__0 ) ) | ( ( rule__NamedPropertyAccess__Group_1__0 ) ) );
+ public final void rule__NamedPropertyAccess__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2494:1: ( ( ( rule__NamedPropertyAccess__Group_0__0 ) ) | ( ( rule__NamedPropertyAccess__Group_1__0 ) ) )
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( ((LA23_0>=RULE_DOT && LA23_0<=RULE_QUESTION_DOT)) ) {
+ alt23=1;
+ }
+ else if ( (LA23_0==RULE_DOUBLE_COLON) ) {
+ alt23=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 23, 0, input);
+
+ throw nvae;
+ }
+ switch (alt23) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2495:1: ( ( rule__NamedPropertyAccess__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2495:1: ( ( rule__NamedPropertyAccess__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2496:1: ( rule__NamedPropertyAccess__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2497:1: ( rule__NamedPropertyAccess__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2497:2: rule__NamedPropertyAccess__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__Group_0__0_in_rule__NamedPropertyAccess__Alternatives5380);
+ rule__NamedPropertyAccess__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2501:6: ( ( rule__NamedPropertyAccess__Group_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2501:6: ( ( rule__NamedPropertyAccess__Group_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2502:1: ( rule__NamedPropertyAccess__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2503:1: ( rule__NamedPropertyAccess__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2503:2: rule__NamedPropertyAccess__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__Group_1__0_in_rule__NamedPropertyAccess__Alternatives5398);
+ rule__NamedPropertyAccess__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__Alternatives"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__AccessorAlternatives_0_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2512:1: rule__NamedPropertyAccess__AccessorAlternatives_0_0_0 : ( ( RULE_DOT ) | ( RULE_QUESTION_DOT ) );
+ public final void rule__NamedPropertyAccess__AccessorAlternatives_0_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2516:1: ( ( RULE_DOT ) | ( RULE_QUESTION_DOT ) )
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0==RULE_DOT) ) {
+ alt24=1;
+ }
+ else if ( (LA24_0==RULE_QUESTION_DOT) ) {
+ alt24=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 24, 0, input);
+
+ throw nvae;
+ }
+ switch (alt24) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2517:1: ( RULE_DOT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2517:1: ( RULE_DOT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2518:1: RULE_DOT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0());
+ }
+ match(input,RULE_DOT,FOLLOW_RULE_DOT_in_rule__NamedPropertyAccess__AccessorAlternatives_0_0_05431); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2523:6: ( RULE_QUESTION_DOT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2523:6: ( RULE_QUESTION_DOT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2524:1: RULE_QUESTION_DOT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1());
+ }
+ match(input,RULE_QUESTION_DOT,FOLLOW_RULE_QUESTION_DOT_in_rule__NamedPropertyAccess__AccessorAlternatives_0_0_05448); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__AccessorAlternatives_0_0_0"
+
+
+ // $ANTLR start "rule__Index__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2534:1: rule__Index__Alternatives : ( ( ( rule__Index__Group_0__0 ) ) | ( ( rule__Index__Group_1__0 ) ) | ( ( rule__Index__ExpAssignment_2 ) ) );
+ public final void rule__Index__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2538:1: ( ( ( rule__Index__Group_0__0 ) ) | ( ( rule__Index__Group_1__0 ) ) | ( ( rule__Index__ExpAssignment_2 ) ) )
+ int alt25=3;
+ alt25 = dfa25.predict(input);
+ switch (alt25) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2539:1: ( ( rule__Index__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2539:1: ( ( rule__Index__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2540:1: ( rule__Index__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2541:1: ( rule__Index__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2541:2: rule__Index__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__Index__Group_0__0_in_rule__Index__Alternatives5480);
+ rule__Index__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2545:6: ( ( rule__Index__Group_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2545:6: ( ( rule__Index__Group_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2546:1: ( rule__Index__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2547:1: ( rule__Index__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2547:2: rule__Index__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__Index__Group_1__0_in_rule__Index__Alternatives5498);
+ rule__Index__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2551:6: ( ( rule__Index__ExpAssignment_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2551:6: ( ( rule__Index__ExpAssignment_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2552:1: ( rule__Index__ExpAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getExpAssignment_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2553:1: ( rule__Index__ExpAssignment_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2553:2: rule__Index__ExpAssignment_2
+ {
+ pushFollow(FOLLOW_rule__Index__ExpAssignment_2_in_rule__Index__Alternatives5516);
+ rule__Index__ExpAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getExpAssignment_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Alternatives"
+
+
+ // $ANTLR start "rule__Index__DotsAlternatives_0_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2562:1: rule__Index__DotsAlternatives_0_0_0 : ( ( RULE_DOT_DOT ) | ( RULE_ELLIPSIS ) );
+ public final void rule__Index__DotsAlternatives_0_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2566:1: ( ( RULE_DOT_DOT ) | ( RULE_ELLIPSIS ) )
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0==RULE_DOT_DOT) ) {
+ alt26=1;
+ }
+ else if ( (LA26_0==RULE_ELLIPSIS) ) {
+ alt26=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 26, 0, input);
+
+ throw nvae;
+ }
+ switch (alt26) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2567:1: ( RULE_DOT_DOT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2567:1: ( RULE_DOT_DOT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2568:1: RULE_DOT_DOT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0());
+ }
+ match(input,RULE_DOT_DOT,FOLLOW_RULE_DOT_DOT_in_rule__Index__DotsAlternatives_0_0_05549); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2573:6: ( RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2573:6: ( RULE_ELLIPSIS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2574:1: RULE_ELLIPSIS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1());
+ }
+ match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_rule__Index__DotsAlternatives_0_0_05566); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__DotsAlternatives_0_0_0"
+
+
+ // $ANTLR start "rule__Index__DotsAlternatives_1_0_0_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2584:1: rule__Index__DotsAlternatives_1_0_0_1_0 : ( ( RULE_DOT_DOT ) | ( RULE_ELLIPSIS ) );
+ public final void rule__Index__DotsAlternatives_1_0_0_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2588:1: ( ( RULE_DOT_DOT ) | ( RULE_ELLIPSIS ) )
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( (LA27_0==RULE_DOT_DOT) ) {
+ alt27=1;
+ }
+ else if ( (LA27_0==RULE_ELLIPSIS) ) {
+ alt27=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 27, 0, input);
+
+ throw nvae;
+ }
+ switch (alt27) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2589:1: ( RULE_DOT_DOT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2589:1: ( RULE_DOT_DOT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2590:1: RULE_DOT_DOT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0());
+ }
+ match(input,RULE_DOT_DOT,FOLLOW_RULE_DOT_DOT_in_rule__Index__DotsAlternatives_1_0_0_1_05598); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2595:6: ( RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2595:6: ( RULE_ELLIPSIS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2596:1: RULE_ELLIPSIS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1());
+ }
+ match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_rule__Index__DotsAlternatives_1_0_0_1_05615); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__DotsAlternatives_1_0_0_1_0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2606:1: rule__PrimaryExpression__Alternatives : ( ( ruleIfExp ) | ( ruleParenthetical ) | ( ruleLiteral ) | ( ( ruleRange ) ) | ( ( ruleArray ) ) | ( ( ruleDictionary ) ) | ( ruleLambda ) | ( ruleThisProperty ) | ( ( rule__PrimaryExpression__Group_8__0 ) ) | ( ( rule__PrimaryExpression__Group_9__0 ) ) | ( ( rule__PrimaryExpression__Group_10__0 ) ) | ( ( rule__PrimaryExpression__Group_11__0 ) ) | ( ( rule__PrimaryExpression__Group_12__0 ) ) | ( ( rule__PrimaryExpression__Group_13__0 ) ) | ( ( rule__PrimaryExpression__Group_14__0 ) ) | ( ruleIdRef ) );
+ public final void rule__PrimaryExpression__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2610:1: ( ( ruleIfExp ) | ( ruleParenthetical ) | ( ruleLiteral ) | ( ( ruleRange ) ) | ( ( ruleArray ) ) | ( ( ruleDictionary ) ) | ( ruleLambda ) | ( ruleThisProperty ) | ( ( rule__PrimaryExpression__Group_8__0 ) ) | ( ( rule__PrimaryExpression__Group_9__0 ) ) | ( ( rule__PrimaryExpression__Group_10__0 ) ) | ( ( rule__PrimaryExpression__Group_11__0 ) ) | ( ( rule__PrimaryExpression__Group_12__0 ) ) | ( ( rule__PrimaryExpression__Group_13__0 ) ) | ( ( rule__PrimaryExpression__Group_14__0 ) ) | ( ruleIdRef ) )
+ int alt28=16;
+ alt28 = dfa28.predict(input);
+ switch (alt28) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2611:1: ( ruleIfExp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2611:1: ( ruleIfExp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2612:1: ruleIfExp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleIfExp_in_rule__PrimaryExpression__Alternatives5647);
+ ruleIfExp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2617:6: ( ruleParenthetical )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2617:6: ( ruleParenthetical )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2618:1: ruleParenthetical
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleParenthetical_in_rule__PrimaryExpression__Alternatives5664);
+ ruleParenthetical();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2623:6: ( ruleLiteral )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2623:6: ( ruleLiteral )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2624:1: ruleLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2());
+ }
+ pushFollow(FOLLOW_ruleLiteral_in_rule__PrimaryExpression__Alternatives5681);
+ ruleLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2629:6: ( ( ruleRange ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2629:6: ( ( ruleRange ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2630:1: ( ruleRange )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2631:1: ( ruleRange )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2631:3: ruleRange
+ {
+ pushFollow(FOLLOW_ruleRange_in_rule__PrimaryExpression__Alternatives5699);
+ ruleRange();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3());
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2635:6: ( ( ruleArray ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2635:6: ( ( ruleArray ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2636:1: ( ruleArray )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2637:1: ( ruleArray )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2637:3: ruleArray
+ {
+ pushFollow(FOLLOW_ruleArray_in_rule__PrimaryExpression__Alternatives5718);
+ ruleArray();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4());
+ }
+
+ }
+
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2641:6: ( ( ruleDictionary ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2641:6: ( ( ruleDictionary ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2642:1: ( ruleDictionary )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2643:1: ( ruleDictionary )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2643:3: ruleDictionary
+ {
+ pushFollow(FOLLOW_ruleDictionary_in_rule__PrimaryExpression__Alternatives5737);
+ ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5());
+ }
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2647:6: ( ruleLambda )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2647:6: ( ruleLambda )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2648:1: ruleLambda
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6());
+ }
+ pushFollow(FOLLOW_ruleLambda_in_rule__PrimaryExpression__Alternatives5755);
+ ruleLambda();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6());
+ }
+
+ }
+
+
+ }
+ break;
+ case 8 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2653:6: ( ruleThisProperty )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2653:6: ( ruleThisProperty )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2654:1: ruleThisProperty
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7());
+ }
+ pushFollow(FOLLOW_ruleThisProperty_in_rule__PrimaryExpression__Alternatives5772);
+ ruleThisProperty();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7());
+ }
+
+ }
+
+
+ }
+ break;
+ case 9 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2659:6: ( ( rule__PrimaryExpression__Group_8__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2659:6: ( ( rule__PrimaryExpression__Group_8__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2660:1: ( rule__PrimaryExpression__Group_8__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_8());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2661:1: ( rule__PrimaryExpression__Group_8__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2661:2: rule__PrimaryExpression__Group_8__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_8__0_in_rule__PrimaryExpression__Alternatives5789);
+ rule__PrimaryExpression__Group_8__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_8());
+ }
+
+ }
+
+
+ }
+ break;
+ case 10 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2665:6: ( ( rule__PrimaryExpression__Group_9__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2665:6: ( ( rule__PrimaryExpression__Group_9__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2666:1: ( rule__PrimaryExpression__Group_9__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_9());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2667:1: ( rule__PrimaryExpression__Group_9__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2667:2: rule__PrimaryExpression__Group_9__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9__0_in_rule__PrimaryExpression__Alternatives5807);
+ rule__PrimaryExpression__Group_9__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_9());
+ }
+
+ }
+
+
+ }
+ break;
+ case 11 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2671:6: ( ( rule__PrimaryExpression__Group_10__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2671:6: ( ( rule__PrimaryExpression__Group_10__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2672:1: ( rule__PrimaryExpression__Group_10__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_10());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2673:1: ( rule__PrimaryExpression__Group_10__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2673:2: rule__PrimaryExpression__Group_10__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10__0_in_rule__PrimaryExpression__Alternatives5825);
+ rule__PrimaryExpression__Group_10__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_10());
+ }
+
+ }
+
+
+ }
+ break;
+ case 12 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2677:6: ( ( rule__PrimaryExpression__Group_11__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2677:6: ( ( rule__PrimaryExpression__Group_11__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2678:1: ( rule__PrimaryExpression__Group_11__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_11());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2679:1: ( rule__PrimaryExpression__Group_11__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2679:2: rule__PrimaryExpression__Group_11__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11__0_in_rule__PrimaryExpression__Alternatives5843);
+ rule__PrimaryExpression__Group_11__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_11());
+ }
+
+ }
+
+
+ }
+ break;
+ case 13 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2683:6: ( ( rule__PrimaryExpression__Group_12__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2683:6: ( ( rule__PrimaryExpression__Group_12__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2684:1: ( rule__PrimaryExpression__Group_12__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_12());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2685:1: ( rule__PrimaryExpression__Group_12__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2685:2: rule__PrimaryExpression__Group_12__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_12__0_in_rule__PrimaryExpression__Alternatives5861);
+ rule__PrimaryExpression__Group_12__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_12());
+ }
+
+ }
+
+
+ }
+ break;
+ case 14 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2689:6: ( ( rule__PrimaryExpression__Group_13__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2689:6: ( ( rule__PrimaryExpression__Group_13__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2690:1: ( rule__PrimaryExpression__Group_13__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2691:1: ( rule__PrimaryExpression__Group_13__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2691:2: rule__PrimaryExpression__Group_13__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13__0_in_rule__PrimaryExpression__Alternatives5879);
+ rule__PrimaryExpression__Group_13__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13());
+ }
+
+ }
+
+
+ }
+ break;
+ case 15 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2695:6: ( ( rule__PrimaryExpression__Group_14__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2695:6: ( ( rule__PrimaryExpression__Group_14__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2696:1: ( rule__PrimaryExpression__Group_14__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_14());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2697:1: ( rule__PrimaryExpression__Group_14__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2697:2: rule__PrimaryExpression__Group_14__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14__0_in_rule__PrimaryExpression__Alternatives5897);
+ rule__PrimaryExpression__Group_14__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_14());
+ }
+
+ }
+
+
+ }
+ break;
+ case 16 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2701:6: ( ruleIdRef )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2701:6: ( ruleIdRef )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2702:1: ruleIdRef
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15());
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_rule__PrimaryExpression__Alternatives5915);
+ ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Alternatives"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Alternatives_13_1_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2712:1: rule__PrimaryExpression__Alternatives_13_1_2 : ( ( ( rule__PrimaryExpression__Group_13_1_2_0__0 ) ) | ( ( rule__PrimaryExpression__Group_13_1_2_1__0 ) ) );
+ public final void rule__PrimaryExpression__Alternatives_13_1_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2716:1: ( ( ( rule__PrimaryExpression__Group_13_1_2_0__0 ) ) | ( ( rule__PrimaryExpression__Group_13_1_2_1__0 ) ) )
+ int alt29=2;
+ int LA29_0 = input.LA(1);
+
+ if ( (LA29_0==RULE_CATCH) ) {
+ alt29=1;
+ }
+ else if ( (LA29_0==RULE_FINALLY) ) {
+ alt29=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 29, 0, input);
+
+ throw nvae;
+ }
+ switch (alt29) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2717:1: ( ( rule__PrimaryExpression__Group_13_1_2_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2717:1: ( ( rule__PrimaryExpression__Group_13_1_2_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2718:1: ( rule__PrimaryExpression__Group_13_1_2_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2719:1: ( rule__PrimaryExpression__Group_13_1_2_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2719:2: rule__PrimaryExpression__Group_13_1_2_0__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__0_in_rule__PrimaryExpression__Alternatives_13_1_25947);
+ rule__PrimaryExpression__Group_13_1_2_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2723:6: ( ( rule__PrimaryExpression__Group_13_1_2_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2723:6: ( ( rule__PrimaryExpression__Group_13_1_2_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2724:1: ( rule__PrimaryExpression__Group_13_1_2_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2725:1: ( rule__PrimaryExpression__Group_13_1_2_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2725:2: rule__PrimaryExpression__Group_13_1_2_1__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_1__0_in_rule__PrimaryExpression__Alternatives_13_1_25965);
+ rule__PrimaryExpression__Group_13_1_2_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Alternatives_13_1_2"
+
+
+ // $ANTLR start "rule__Property__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2734:1: rule__Property__Alternatives : ( ( ( rule__Property__Group_0__0 ) ) | ( ( rule__Property__Group_1__0 ) ) );
+ public final void rule__Property__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2738:1: ( ( ( rule__Property__Group_0__0 ) ) | ( ( rule__Property__Group_1__0 ) ) )
+ int alt30=2;
+ int LA30_0 = input.LA(1);
+
+ if ( (LA30_0==RULE_IDENTIFIER) ) {
+ int LA30_1 = input.LA(2);
+
+ if ( ((LA30_1>=RULE_DOT && LA30_1<=RULE_DOUBLE_COLON)) ) {
+ alt30=1;
+ }
+ else if ( (LA30_1==RULE_INDEX_START) ) {
+ alt30=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 30, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 30, 0, input);
+
+ throw nvae;
+ }
+ switch (alt30) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2739:1: ( ( rule__Property__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2739:1: ( ( rule__Property__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2740:1: ( rule__Property__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2741:1: ( rule__Property__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2741:2: rule__Property__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__Property__Group_0__0_in_rule__Property__Alternatives5998);
+ rule__Property__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2745:6: ( ( rule__Property__Group_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2745:6: ( ( rule__Property__Group_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2746:1: ( rule__Property__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2747:1: ( rule__Property__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2747:2: rule__Property__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__Property__Group_1__0_in_rule__Property__Alternatives6016);
+ rule__Property__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Alternatives"
+
+
+ // $ANTLR start "rule__Property__AccessorAlternatives_0_0_0_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2756:1: rule__Property__AccessorAlternatives_0_0_0_1_0 : ( ( RULE_DOT ) | ( RULE_DOUBLE_COLON ) | ( RULE_QUESTION_DOT ) );
+ public final void rule__Property__AccessorAlternatives_0_0_0_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2760:1: ( ( RULE_DOT ) | ( RULE_DOUBLE_COLON ) | ( RULE_QUESTION_DOT ) )
+ int alt31=3;
+ switch ( input.LA(1) ) {
+ case RULE_DOT:
+ {
+ alt31=1;
+ }
+ break;
+ case RULE_DOUBLE_COLON:
+ {
+ alt31=2;
+ }
+ break;
+ case RULE_QUESTION_DOT:
+ {
+ alt31=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 31, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt31) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2761:1: ( RULE_DOT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2761:1: ( RULE_DOT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2762:1: RULE_DOT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0());
+ }
+ match(input,RULE_DOT,FOLLOW_RULE_DOT_in_rule__Property__AccessorAlternatives_0_0_0_1_06049); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2767:6: ( RULE_DOUBLE_COLON )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2767:6: ( RULE_DOUBLE_COLON )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2768:1: RULE_DOUBLE_COLON
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1());
+ }
+ match(input,RULE_DOUBLE_COLON,FOLLOW_RULE_DOUBLE_COLON_in_rule__Property__AccessorAlternatives_0_0_0_1_06066); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2773:6: ( RULE_QUESTION_DOT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2773:6: ( RULE_QUESTION_DOT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2774:1: RULE_QUESTION_DOT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2());
+ }
+ match(input,RULE_QUESTION_DOT,FOLLOW_RULE_QUESTION_DOT_in_rule__Property__AccessorAlternatives_0_0_0_1_06083); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__AccessorAlternatives_0_0_0_1_0"
+
+
+ // $ANTLR start "rule__Variable__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2784:1: rule__Variable__Alternatives : ( ( ruleId ) | ( ( rule__Variable__Group_1__0 ) ) | ( ruleProperty ) );
+ public final void rule__Variable__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2788:1: ( ( ruleId ) | ( ( rule__Variable__Group_1__0 ) ) | ( ruleProperty ) )
+ int alt32=3;
+ int LA32_0 = input.LA(1);
+
+ if ( (LA32_0==RULE_IDENTIFIER) ) {
+ int LA32_1 = input.LA(2);
+
+ if ( ((LA32_1>=RULE_DOT && LA32_1<=RULE_DOUBLE_COLON)||LA32_1==RULE_INDEX_START) ) {
+ alt32=3;
+ }
+ else if ( (LA32_1==EOF||(LA32_1>=RULE_DOT_DOT && LA32_1<=RULE_MINUS)||(LA32_1>=RULE_COMMA && LA32_1<=RULE_TERMINATOR)||LA32_1==RULE_PARAM_END||LA32_1==RULE_POST_IF||(LA32_1>=RULE_FOR && LA32_1<=RULE_UNTIL)||(LA32_1>=RULE_BY && LA32_1<=RULE_RBRACKET)||(LA32_1>=RULE_INDENT && LA32_1<=RULE_OUTDENT)||LA32_1==RULE_INDEX_END||LA32_1==RULE_RCURLY||LA32_1==RULE_RPAREN||(LA32_1>=RULE_LOGIC && LA32_1<=RULE_MATH)) ) {
+ alt32=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 32, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA32_0==RULE_AT_SIGIL||LA32_0==RULE_THIS) ) {
+ alt32=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 32, 0, input);
+
+ throw nvae;
+ }
+ switch (alt32) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2789:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2789:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2790:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getIdParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__Variable__Alternatives6115);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getIdParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2795:6: ( ( rule__Variable__Group_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2795:6: ( ( rule__Variable__Group_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2796:1: ( rule__Variable__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2797:1: ( rule__Variable__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2797:2: rule__Variable__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1__0_in_rule__Variable__Alternatives6132);
+ rule__Variable__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2801:6: ( ruleProperty )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2801:6: ( ruleProperty )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2802:1: ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getPropertyParserRuleCall_2());
+ }
+ pushFollow(FOLLOW_ruleProperty_in_rule__Variable__Alternatives6150);
+ ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getPropertyParserRuleCall_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Alternatives"
+
+
+ // $ANTLR start "rule__Variable__Alternatives_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2812:1: rule__Variable__Alternatives_1_0 : ( ( RULE_AT_SIGIL ) | ( ( rule__Variable__Group_1_0_1__0 ) ) );
+ public final void rule__Variable__Alternatives_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2816:1: ( ( RULE_AT_SIGIL ) | ( ( rule__Variable__Group_1_0_1__0 ) ) )
+ int alt33=2;
+ int LA33_0 = input.LA(1);
+
+ if ( (LA33_0==RULE_AT_SIGIL) ) {
+ alt33=1;
+ }
+ else if ( (LA33_0==RULE_THIS) ) {
+ alt33=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 33, 0, input);
+
+ throw nvae;
+ }
+ switch (alt33) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2817:1: ( RULE_AT_SIGIL )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2817:1: ( RULE_AT_SIGIL )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2818:1: RULE_AT_SIGIL
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0());
+ }
+ match(input,RULE_AT_SIGIL,FOLLOW_RULE_AT_SIGIL_in_rule__Variable__Alternatives_1_06182); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2823:6: ( ( rule__Variable__Group_1_0_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2823:6: ( ( rule__Variable__Group_1_0_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2824:1: ( rule__Variable__Group_1_0_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getGroup_1_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2825:1: ( rule__Variable__Group_1_0_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2825:2: rule__Variable__Group_1_0_1__0
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1_0_1__0_in_rule__Variable__Alternatives_1_06199);
+ rule__Variable__Group_1_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getGroup_1_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Alternatives_1_0"
+
+
+ // $ANTLR start "rule__Assignable__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2834:1: rule__Assignable__Alternatives : ( ( ruleVariable ) | ( ( ruleDictionary ) ) | ( ( ruleAssignableArray ) ) );
+ public final void rule__Assignable__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2838:1: ( ( ruleVariable ) | ( ( ruleDictionary ) ) | ( ( ruleAssignableArray ) ) )
+ int alt34=3;
+ switch ( input.LA(1) ) {
+ case RULE_AT_SIGIL:
+ case RULE_THIS:
+ case RULE_IDENTIFIER:
+ {
+ alt34=1;
+ }
+ break;
+ case RULE_LCURLY:
+ {
+ alt34=2;
+ }
+ break;
+ case RULE_LBRACKET:
+ {
+ alt34=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 34, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt34) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2839:1: ( ruleVariable )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2839:1: ( ruleVariable )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2840:1: ruleVariable
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableAccess().getVariableParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleVariable_in_rule__Assignable__Alternatives6232);
+ ruleVariable();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableAccess().getVariableParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2845:6: ( ( ruleDictionary ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2845:6: ( ( ruleDictionary ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2846:1: ( ruleDictionary )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2847:1: ( ruleDictionary )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2847:3: ruleDictionary
+ {
+ pushFollow(FOLLOW_ruleDictionary_in_rule__Assignable__Alternatives6250);
+ ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2851:6: ( ( ruleAssignableArray ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2851:6: ( ( ruleAssignableArray ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2852:1: ( ruleAssignableArray )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2853:1: ( ruleAssignableArray )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2853:3: ruleAssignableArray
+ {
+ pushFollow(FOLLOW_ruleAssignableArray_in_rule__Assignable__Alternatives6269);
+ ruleAssignableArray();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignable__Alternatives"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Alternatives_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2862:1: rule__ExplicitArgList__Alternatives_1 : ( ( ( rule__ExplicitArgList__Group_1_0__0 ) ) | ( ( rule__ExplicitArgList__Group_1_1__0 ) ) );
+ public final void rule__ExplicitArgList__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2866:1: ( ( ( rule__ExplicitArgList__Group_1_0__0 ) ) | ( ( rule__ExplicitArgList__Group_1_1__0 ) ) )
+ int alt35=2;
+ int LA35_0 = input.LA(1);
+
+ if ( (LA35_0==RULE_TERMINATOR) ) {
+ alt35=1;
+ }
+ else if ( (LA35_0==RULE_INDENT) ) {
+ alt35=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 35, 0, input);
+
+ throw nvae;
+ }
+ switch (alt35) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2867:1: ( ( rule__ExplicitArgList__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2867:1: ( ( rule__ExplicitArgList__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2868:1: ( rule__ExplicitArgList__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2869:1: ( rule__ExplicitArgList__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2869:2: rule__ExplicitArgList__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_0__0_in_rule__ExplicitArgList__Alternatives_16302);
+ rule__ExplicitArgList__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2873:6: ( ( rule__ExplicitArgList__Group_1_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2873:6: ( ( rule__ExplicitArgList__Group_1_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2874:1: ( rule__ExplicitArgList__Group_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getGroup_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2875:1: ( rule__ExplicitArgList__Group_1_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2875:2: rule__ExplicitArgList__Group_1_1__0
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_1__0_in_rule__ExplicitArgList__Alternatives_16320);
+ rule__ExplicitArgList__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Alternatives_1"
+
+
+ // $ANTLR start "rule__ArgList__Alternatives_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2884:1: rule__ArgList__Alternatives_1 : ( ( ( rule__ArgList__DummyAssignment_1_0 ) ) | ( ( rule__ArgList__Group_1_1__0 ) ) );
+ public final void rule__ArgList__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2888:1: ( ( ( rule__ArgList__DummyAssignment_1_0 ) ) | ( ( rule__ArgList__Group_1_1__0 ) ) )
+ int alt36=2;
+ int LA36_0 = input.LA(1);
+
+ if ( ((LA36_0>=RULE_PLUS && LA36_0<=RULE_MINUS_MINUS)||(LA36_0>=RULE_AT_SIGIL && LA36_0<=RULE_BOUND_FUNC_ARROW)||LA36_0==RULE_PARAM_START||(LA36_0>=RULE_FOR && LA36_0<=RULE_WHILE)||LA36_0==RULE_UNTIL||LA36_0==RULE_LBRACKET||LA36_0==RULE_SUPER||(LA36_0>=RULE_THIS && LA36_0<=RULE_TRY)||LA36_0==RULE_SWITCH||LA36_0==RULE_LCURLY||(LA36_0>=RULE_NUMBER && LA36_0<=RULE_REGEX)||LA36_0==RULE_LPAREN||(LA36_0>=RULE_IF && LA36_0<=RULE_IDENTIFIER)) ) {
+ alt36=1;
+ }
+ else if ( (LA36_0==RULE_INDENT) ) {
+ alt36=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 36, 0, input);
+
+ throw nvae;
+ }
+ switch (alt36) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2889:1: ( ( rule__ArgList__DummyAssignment_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2889:1: ( ( rule__ArgList__DummyAssignment_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2890:1: ( rule__ArgList__DummyAssignment_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getDummyAssignment_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2891:1: ( rule__ArgList__DummyAssignment_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2891:2: rule__ArgList__DummyAssignment_1_0
+ {
+ pushFollow(FOLLOW_rule__ArgList__DummyAssignment_1_0_in_rule__ArgList__Alternatives_16353);
+ rule__ArgList__DummyAssignment_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getDummyAssignment_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2895:6: ( ( rule__ArgList__Group_1_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2895:6: ( ( rule__ArgList__Group_1_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2896:1: ( rule__ArgList__Group_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getGroup_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2897:1: ( rule__ArgList__Group_1_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2897:2: rule__ArgList__Group_1_1__0
+ {
+ pushFollow(FOLLOW_rule__ArgList__Group_1_1__0_in_rule__ArgList__Alternatives_16371);
+ rule__ArgList__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Alternatives_1"
+
+
+ // $ANTLR start "rule__DictItems__Alternatives_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2906:1: rule__DictItems__Alternatives_1 : ( ( ( rule__DictItems__DummyAssignment_1_0 ) ) | ( ( rule__DictItems__Group_1_1__0 ) ) );
+ public final void rule__DictItems__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2910:1: ( ( ( rule__DictItems__DummyAssignment_1_0 ) ) | ( ( rule__DictItems__Group_1_1__0 ) ) )
+ int alt37=2;
+ int LA37_0 = input.LA(1);
+
+ if ( ((LA37_0>=RULE_NUMBER && LA37_0<=RULE_REGEX)||LA37_0==RULE_IDENTIFIER) ) {
+ alt37=1;
+ }
+ else if ( (LA37_0==RULE_INDENT) ) {
+ alt37=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 37, 0, input);
+
+ throw nvae;
+ }
+ switch (alt37) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2911:1: ( ( rule__DictItems__DummyAssignment_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2911:1: ( ( rule__DictItems__DummyAssignment_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2912:1: ( rule__DictItems__DummyAssignment_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getDummyAssignment_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2913:1: ( rule__DictItems__DummyAssignment_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2913:2: rule__DictItems__DummyAssignment_1_0
+ {
+ pushFollow(FOLLOW_rule__DictItems__DummyAssignment_1_0_in_rule__DictItems__Alternatives_16404);
+ rule__DictItems__DummyAssignment_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getDummyAssignment_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2917:6: ( ( rule__DictItems__Group_1_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2917:6: ( ( rule__DictItems__Group_1_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2918:1: ( rule__DictItems__Group_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getGroup_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2919:1: ( rule__DictItems__Group_1_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2919:2: rule__DictItems__Group_1_1__0
+ {
+ pushFollow(FOLLOW_rule__DictItems__Group_1_1__0_in_rule__DictItems__Alternatives_16422);
+ rule__DictItems__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Alternatives_1"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Alternatives_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2928:1: rule__ExplicitDictItems__Alternatives_1 : ( ( ( rule__ExplicitDictItems__Group_1_0__0 ) ) | ( ( rule__ExplicitDictItems__Group_1_1__0 ) ) );
+ public final void rule__ExplicitDictItems__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2932:1: ( ( ( rule__ExplicitDictItems__Group_1_0__0 ) ) | ( ( rule__ExplicitDictItems__Group_1_1__0 ) ) )
+ int alt38=2;
+ int LA38_0 = input.LA(1);
+
+ if ( (LA38_0==RULE_TERMINATOR) ) {
+ alt38=1;
+ }
+ else if ( (LA38_0==RULE_INDENT) ) {
+ alt38=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 38, 0, input);
+
+ throw nvae;
+ }
+ switch (alt38) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2933:1: ( ( rule__ExplicitDictItems__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2933:1: ( ( rule__ExplicitDictItems__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2934:1: ( rule__ExplicitDictItems__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2935:1: ( rule__ExplicitDictItems__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2935:2: rule__ExplicitDictItems__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_0__0_in_rule__ExplicitDictItems__Alternatives_16455);
+ rule__ExplicitDictItems__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2939:6: ( ( rule__ExplicitDictItems__Group_1_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2939:6: ( ( rule__ExplicitDictItems__Group_1_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2940:1: ( rule__ExplicitDictItems__Group_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getGroup_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2941:1: ( rule__ExplicitDictItems__Group_1_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2941:2: rule__ExplicitDictItems__Group_1_1__0
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_1__0_in_rule__ExplicitDictItems__Alternatives_16473);
+ rule__ExplicitDictItems__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Alternatives_1"
+
+
+ // $ANTLR start "rule__DictItem__Alternatives_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2950:1: rule__DictItem__Alternatives_2_1 : ( ( ( rule__DictItem__ValueAssignment_2_1_0 ) ) | ( ( rule__DictItem__Group_2_1_1__0 ) ) );
+ public final void rule__DictItem__Alternatives_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2954:1: ( ( ( rule__DictItem__ValueAssignment_2_1_0 ) ) | ( ( rule__DictItem__Group_2_1_1__0 ) ) )
+ int alt39=2;
+ int LA39_0 = input.LA(1);
+
+ if ( ((LA39_0>=RULE_PLUS && LA39_0<=RULE_MINUS_MINUS)||(LA39_0>=RULE_AT_SIGIL && LA39_0<=RULE_BOUND_FUNC_ARROW)||LA39_0==RULE_PARAM_START||(LA39_0>=RULE_FOR && LA39_0<=RULE_WHILE)||LA39_0==RULE_UNTIL||LA39_0==RULE_LBRACKET||LA39_0==RULE_SUPER||(LA39_0>=RULE_THIS && LA39_0<=RULE_TRY)||LA39_0==RULE_SWITCH||LA39_0==RULE_LCURLY||(LA39_0>=RULE_NUMBER && LA39_0<=RULE_REGEX)||LA39_0==RULE_LPAREN||(LA39_0>=RULE_IF && LA39_0<=RULE_IDENTIFIER)) ) {
+ alt39=1;
+ }
+ else if ( (LA39_0==RULE_INDENT) ) {
+ alt39=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 39, 0, input);
+
+ throw nvae;
+ }
+ switch (alt39) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2955:1: ( ( rule__DictItem__ValueAssignment_2_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2955:1: ( ( rule__DictItem__ValueAssignment_2_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2956:1: ( rule__DictItem__ValueAssignment_2_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getValueAssignment_2_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2957:1: ( rule__DictItem__ValueAssignment_2_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2957:2: rule__DictItem__ValueAssignment_2_1_0
+ {
+ pushFollow(FOLLOW_rule__DictItem__ValueAssignment_2_1_0_in_rule__DictItem__Alternatives_2_16506);
+ rule__DictItem__ValueAssignment_2_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getValueAssignment_2_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2961:6: ( ( rule__DictItem__Group_2_1_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2961:6: ( ( rule__DictItem__Group_2_1_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2962:1: ( rule__DictItem__Group_2_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getGroup_2_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2963:1: ( rule__DictItem__Group_2_1_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2963:2: rule__DictItem__Group_2_1_1__0
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group_2_1_1__0_in_rule__DictItem__Alternatives_2_16524);
+ rule__DictItem__Group_2_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getGroup_2_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Alternatives_2_1"
+
+
+ // $ANTLR start "rule__DictKey__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2972:1: rule__DictKey__Alternatives : ( ( ruleLiteral ) | ( ruleId ) );
+ public final void rule__DictKey__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2976:1: ( ( ruleLiteral ) | ( ruleId ) )
+ int alt40=2;
+ int LA40_0 = input.LA(1);
+
+ if ( ((LA40_0>=RULE_NUMBER && LA40_0<=RULE_REGEX)) ) {
+ alt40=1;
+ }
+ else if ( (LA40_0==RULE_IDENTIFIER) ) {
+ alt40=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 40, 0, input);
+
+ throw nvae;
+ }
+ switch (alt40) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2977:1: ( ruleLiteral )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2977:1: ( ruleLiteral )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2978:1: ruleLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleLiteral_in_rule__DictKey__Alternatives6557);
+ ruleLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2983:6: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2983:6: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2984:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictKeyAccess().getIdParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__DictKey__Alternatives6574);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictKeyAccess().getIdParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictKey__Alternatives"
+
+
+ // $ANTLR start "rule__Lambda__Alternatives_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2994:1: rule__Lambda__Alternatives_1 : ( ( RULE_FUNC_ARROW ) | ( RULE_BOUND_FUNC_ARROW ) );
+ public final void rule__Lambda__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2998:1: ( ( RULE_FUNC_ARROW ) | ( RULE_BOUND_FUNC_ARROW ) )
+ int alt41=2;
+ int LA41_0 = input.LA(1);
+
+ if ( (LA41_0==RULE_FUNC_ARROW) ) {
+ alt41=1;
+ }
+ else if ( (LA41_0==RULE_BOUND_FUNC_ARROW) ) {
+ alt41=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 41, 0, input);
+
+ throw nvae;
+ }
+ switch (alt41) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2999:1: ( RULE_FUNC_ARROW )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2999:1: ( RULE_FUNC_ARROW )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3000:1: RULE_FUNC_ARROW
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0());
+ }
+ match(input,RULE_FUNC_ARROW,FOLLOW_RULE_FUNC_ARROW_in_rule__Lambda__Alternatives_16606); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3005:6: ( RULE_BOUND_FUNC_ARROW )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3005:6: ( RULE_BOUND_FUNC_ARROW )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3006:1: RULE_BOUND_FUNC_ARROW
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getBOUND_FUNC_ARROWTerminalRuleCall_1_1());
+ }
+ match(input,RULE_BOUND_FUNC_ARROW,FOLLOW_RULE_BOUND_FUNC_ARROW_in_rule__Lambda__Alternatives_16623); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getBOUND_FUNC_ARROWTerminalRuleCall_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Alternatives_1"
+
+
+ // $ANTLR start "rule__Param__Alternatives_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3016:1: rule__Param__Alternatives_0 : ( ( ruleId ) | ( ( ruleArray ) ) | ( ( ruleDictionary ) ) | ( ruleThisProperty ) );
+ public final void rule__Param__Alternatives_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3020:1: ( ( ruleId ) | ( ( ruleArray ) ) | ( ( ruleDictionary ) ) | ( ruleThisProperty ) )
+ int alt42=4;
+ switch ( input.LA(1) ) {
+ case RULE_IDENTIFIER:
+ {
+ alt42=1;
+ }
+ break;
+ case RULE_LBRACKET:
+ {
+ alt42=2;
+ }
+ break;
+ case RULE_LCURLY:
+ {
+ alt42=3;
+ }
+ break;
+ case RULE_AT_SIGIL:
+ {
+ alt42=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 42, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt42) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3021:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3021:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3022:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getIdParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__Param__Alternatives_06655);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getIdParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3027:6: ( ( ruleArray ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3027:6: ( ( ruleArray ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3028:1: ( ruleArray )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getArrayParserRuleCall_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3029:1: ( ruleArray )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3029:3: ruleArray
+ {
+ pushFollow(FOLLOW_ruleArray_in_rule__Param__Alternatives_06673);
+ ruleArray();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getArrayParserRuleCall_0_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3033:6: ( ( ruleDictionary ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3033:6: ( ( ruleDictionary ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3034:1: ( ruleDictionary )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3035:1: ( ruleDictionary )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3035:3: ruleDictionary
+ {
+ pushFollow(FOLLOW_ruleDictionary_in_rule__Param__Alternatives_06692);
+ ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3039:6: ( ruleThisProperty )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3039:6: ( ruleThisProperty )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3040:1: ruleThisProperty
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3());
+ }
+ pushFollow(FOLLOW_ruleThisProperty_in_rule__Param__Alternatives_06710);
+ ruleThisProperty();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Alternatives_0"
+
+
+ // $ANTLR start "rule__Param__Alternatives_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3050:1: rule__Param__Alternatives_1 : ( ( ( rule__Param__SplatAssignment_1_0 ) ) | ( ( rule__Param__Group_1_1__0 ) ) );
+ public final void rule__Param__Alternatives_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3054:1: ( ( ( rule__Param__SplatAssignment_1_0 ) ) | ( ( rule__Param__Group_1_1__0 ) ) )
+ int alt43=2;
+ int LA43_0 = input.LA(1);
+
+ if ( (LA43_0==RULE_ELLIPSIS) ) {
+ alt43=1;
+ }
+ else if ( (LA43_0==RULE_EQUAL) ) {
+ alt43=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 43, 0, input);
+
+ throw nvae;
+ }
+ switch (alt43) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3055:1: ( ( rule__Param__SplatAssignment_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3055:1: ( ( rule__Param__SplatAssignment_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3056:1: ( rule__Param__SplatAssignment_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getSplatAssignment_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3057:1: ( rule__Param__SplatAssignment_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3057:2: rule__Param__SplatAssignment_1_0
+ {
+ pushFollow(FOLLOW_rule__Param__SplatAssignment_1_0_in_rule__Param__Alternatives_16742);
+ rule__Param__SplatAssignment_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getSplatAssignment_1_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3061:6: ( ( rule__Param__Group_1_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3061:6: ( ( rule__Param__Group_1_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3062:1: ( rule__Param__Group_1_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getGroup_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3063:1: ( rule__Param__Group_1_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3063:2: rule__Param__Group_1_1__0
+ {
+ pushFollow(FOLLOW_rule__Param__Group_1_1__0_in_rule__Param__Alternatives_16760);
+ rule__Param__Group_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getGroup_1_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Alternatives_1"
+
+
+ // $ANTLR start "rule__Literal__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3072:1: rule__Literal__Alternatives : ( ( ruleNumberLiteral ) | ( ruleStringLiteral ) | ( ruleBoolLiteral ) | ( ruleJSLiteral ) | ( ruleRegexLiteral ) );
+ public final void rule__Literal__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3076:1: ( ( ruleNumberLiteral ) | ( ruleStringLiteral ) | ( ruleBoolLiteral ) | ( ruleJSLiteral ) | ( ruleRegexLiteral ) )
+ int alt44=5;
+ switch ( input.LA(1) ) {
+ case RULE_NUMBER:
+ {
+ alt44=1;
+ }
+ break;
+ case RULE_STRING:
+ {
+ alt44=2;
+ }
+ break;
+ case RULE_BOOL:
+ {
+ alt44=3;
+ }
+ break;
+ case RULE_JS:
+ {
+ alt44=4;
+ }
+ break;
+ case RULE_REGEX:
+ {
+ alt44=5;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 44, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt44) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3077:1: ( ruleNumberLiteral )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3077:1: ( ruleNumberLiteral )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3078:1: ruleNumberLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleNumberLiteral_in_rule__Literal__Alternatives6793);
+ ruleNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3083:6: ( ruleStringLiteral )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3083:6: ( ruleStringLiteral )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3084:1: ruleStringLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_rule__Literal__Alternatives6810);
+ ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3089:6: ( ruleBoolLiteral )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3089:6: ( ruleBoolLiteral )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3090:1: ruleBoolLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2());
+ }
+ pushFollow(FOLLOW_ruleBoolLiteral_in_rule__Literal__Alternatives6827);
+ ruleBoolLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2());
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3095:6: ( ruleJSLiteral )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3095:6: ( ruleJSLiteral )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3096:1: ruleJSLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3());
+ }
+ pushFollow(FOLLOW_ruleJSLiteral_in_rule__Literal__Alternatives6844);
+ ruleJSLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3());
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3101:6: ( ruleRegexLiteral )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3101:6: ( ruleRegexLiteral )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3102:1: ruleRegexLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4());
+ }
+ pushFollow(FOLLOW_ruleRegexLiteral_in_rule__Literal__Alternatives6861);
+ ruleRegexLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Literal__Alternatives"
+
+
+ // $ANTLR start "rule__Parenthetical__Alternatives"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3112:1: rule__Parenthetical__Alternatives : ( ( ( rule__Parenthetical__Group_0__0 ) ) | ( ( rule__Parenthetical__Group_1__0 ) ) );
+ public final void rule__Parenthetical__Alternatives() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3116:1: ( ( ( rule__Parenthetical__Group_0__0 ) ) | ( ( rule__Parenthetical__Group_1__0 ) ) )
+ int alt45=2;
+ int LA45_0 = input.LA(1);
+
+ if ( (LA45_0==RULE_LPAREN) ) {
+ int LA45_1 = input.LA(2);
+
+ if ( ((LA45_1>=RULE_PLUS && LA45_1<=RULE_MINUS_MINUS)||(LA45_1>=RULE_AT_SIGIL && LA45_1<=RULE_BOUND_FUNC_ARROW)||LA45_1==RULE_PARAM_START||LA45_1==RULE_RETURN||(LA45_1>=RULE_THROW && LA45_1<=RULE_CLASS)||(LA45_1>=RULE_FOR && LA45_1<=RULE_WHILE)||LA45_1==RULE_UNTIL||LA45_1==RULE_LBRACKET||LA45_1==RULE_SUPER||(LA45_1>=RULE_THIS && LA45_1<=RULE_TRY)||LA45_1==RULE_SWITCH||LA45_1==RULE_LCURLY||(LA45_1>=RULE_NUMBER && LA45_1<=RULE_REGEX)||(LA45_1>=RULE_LPAREN && LA45_1<=RULE_HERECOMMENT)||(LA45_1>=RULE_IF && LA45_1<=RULE_IDENTIFIER)) ) {
+ alt45=2;
+ }
+ else if ( (LA45_1==RULE_INDENT) ) {
+ alt45=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 45, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 45, 0, input);
+
+ throw nvae;
+ }
+ switch (alt45) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3117:1: ( ( rule__Parenthetical__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3117:1: ( ( rule__Parenthetical__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3118:1: ( rule__Parenthetical__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3119:1: ( rule__Parenthetical__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3119:2: rule__Parenthetical__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0__0_in_rule__Parenthetical__Alternatives6893);
+ rule__Parenthetical__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3123:6: ( ( rule__Parenthetical__Group_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3123:6: ( ( rule__Parenthetical__Group_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3124:1: ( rule__Parenthetical__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3125:1: ( rule__Parenthetical__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3125:2: rule__Parenthetical__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_1__0_in_rule__Parenthetical__Alternatives6911);
+ rule__Parenthetical__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Alternatives"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3136:1: rule__TaskDeclaration__Group__0 : rule__TaskDeclaration__Group__0__Impl rule__TaskDeclaration__Group__1 ;
+ public final void rule__TaskDeclaration__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3140:1: ( rule__TaskDeclaration__Group__0__Impl rule__TaskDeclaration__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3141:2: rule__TaskDeclaration__Group__0__Impl rule__TaskDeclaration__Group__1
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__0__Impl_in_rule__TaskDeclaration__Group__06942);
+ rule__TaskDeclaration__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__1_in_rule__TaskDeclaration__Group__06945);
+ rule__TaskDeclaration__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__0"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3148:1: rule__TaskDeclaration__Group__0__Impl : ( RULE_TASK ) ;
+ public final void rule__TaskDeclaration__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3152:1: ( ( RULE_TASK ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3153:1: ( RULE_TASK )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3153:1: ( RULE_TASK )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3154:1: RULE_TASK
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getTASKTerminalRuleCall_0());
+ }
+ match(input,RULE_TASK,FOLLOW_RULE_TASK_in_rule__TaskDeclaration__Group__0__Impl6972); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getTASKTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__0__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3165:1: rule__TaskDeclaration__Group__1 : rule__TaskDeclaration__Group__1__Impl rule__TaskDeclaration__Group__2 ;
+ public final void rule__TaskDeclaration__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3169:1: ( rule__TaskDeclaration__Group__1__Impl rule__TaskDeclaration__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3170:2: rule__TaskDeclaration__Group__1__Impl rule__TaskDeclaration__Group__2
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__1__Impl_in_rule__TaskDeclaration__Group__17001);
+ rule__TaskDeclaration__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__2_in_rule__TaskDeclaration__Group__17004);
+ rule__TaskDeclaration__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__1"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3177:1: rule__TaskDeclaration__Group__1__Impl : ( RULE_CALL_START ) ;
+ public final void rule__TaskDeclaration__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3181:1: ( ( RULE_CALL_START ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3182:1: ( RULE_CALL_START )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3182:1: ( RULE_CALL_START )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3183:1: RULE_CALL_START
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getCALL_STARTTerminalRuleCall_1());
+ }
+ match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_rule__TaskDeclaration__Group__1__Impl7031); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getCALL_STARTTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__1__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3194:1: rule__TaskDeclaration__Group__2 : rule__TaskDeclaration__Group__2__Impl rule__TaskDeclaration__Group__3 ;
+ public final void rule__TaskDeclaration__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3198:1: ( rule__TaskDeclaration__Group__2__Impl rule__TaskDeclaration__Group__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3199:2: rule__TaskDeclaration__Group__2__Impl rule__TaskDeclaration__Group__3
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__2__Impl_in_rule__TaskDeclaration__Group__27060);
+ rule__TaskDeclaration__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__3_in_rule__TaskDeclaration__Group__27063);
+ rule__TaskDeclaration__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__2"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3206:1: rule__TaskDeclaration__Group__2__Impl : ( ( rule__TaskDeclaration__NameAssignment_2 ) ) ;
+ public final void rule__TaskDeclaration__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3210:1: ( ( ( rule__TaskDeclaration__NameAssignment_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3211:1: ( ( rule__TaskDeclaration__NameAssignment_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3211:1: ( ( rule__TaskDeclaration__NameAssignment_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3212:1: ( rule__TaskDeclaration__NameAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getNameAssignment_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3213:1: ( rule__TaskDeclaration__NameAssignment_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3213:2: rule__TaskDeclaration__NameAssignment_2
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__NameAssignment_2_in_rule__TaskDeclaration__Group__2__Impl7090);
+ rule__TaskDeclaration__NameAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getNameAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__2__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3223:1: rule__TaskDeclaration__Group__3 : rule__TaskDeclaration__Group__3__Impl rule__TaskDeclaration__Group__4 ;
+ public final void rule__TaskDeclaration__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3227:1: ( rule__TaskDeclaration__Group__3__Impl rule__TaskDeclaration__Group__4 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3228:2: rule__TaskDeclaration__Group__3__Impl rule__TaskDeclaration__Group__4
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__3__Impl_in_rule__TaskDeclaration__Group__37120);
+ rule__TaskDeclaration__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__4_in_rule__TaskDeclaration__Group__37123);
+ rule__TaskDeclaration__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__3"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3235:1: rule__TaskDeclaration__Group__3__Impl : ( RULE_COMMA ) ;
+ public final void rule__TaskDeclaration__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3239:1: ( ( RULE_COMMA ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3240:1: ( RULE_COMMA )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3240:1: ( RULE_COMMA )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3241:1: RULE_COMMA
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_3());
+ }
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__TaskDeclaration__Group__3__Impl7150); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__3__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__4"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3252:1: rule__TaskDeclaration__Group__4 : rule__TaskDeclaration__Group__4__Impl rule__TaskDeclaration__Group__5 ;
+ public final void rule__TaskDeclaration__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3256:1: ( rule__TaskDeclaration__Group__4__Impl rule__TaskDeclaration__Group__5 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3257:2: rule__TaskDeclaration__Group__4__Impl rule__TaskDeclaration__Group__5
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__4__Impl_in_rule__TaskDeclaration__Group__47179);
+ rule__TaskDeclaration__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__5_in_rule__TaskDeclaration__Group__47182);
+ rule__TaskDeclaration__Group__5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__4"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__4__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3264:1: rule__TaskDeclaration__Group__4__Impl : ( ( rule__TaskDeclaration__DescriptionAssignment_4 ) ) ;
+ public final void rule__TaskDeclaration__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3268:1: ( ( ( rule__TaskDeclaration__DescriptionAssignment_4 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3269:1: ( ( rule__TaskDeclaration__DescriptionAssignment_4 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3269:1: ( ( rule__TaskDeclaration__DescriptionAssignment_4 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3270:1: ( rule__TaskDeclaration__DescriptionAssignment_4 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getDescriptionAssignment_4());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3271:1: ( rule__TaskDeclaration__DescriptionAssignment_4 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3271:2: rule__TaskDeclaration__DescriptionAssignment_4
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__DescriptionAssignment_4_in_rule__TaskDeclaration__Group__4__Impl7209);
+ rule__TaskDeclaration__DescriptionAssignment_4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getDescriptionAssignment_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__4__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__5"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3281:1: rule__TaskDeclaration__Group__5 : rule__TaskDeclaration__Group__5__Impl rule__TaskDeclaration__Group__6 ;
+ public final void rule__TaskDeclaration__Group__5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3285:1: ( rule__TaskDeclaration__Group__5__Impl rule__TaskDeclaration__Group__6 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3286:2: rule__TaskDeclaration__Group__5__Impl rule__TaskDeclaration__Group__6
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__5__Impl_in_rule__TaskDeclaration__Group__57239);
+ rule__TaskDeclaration__Group__5__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__6_in_rule__TaskDeclaration__Group__57242);
+ rule__TaskDeclaration__Group__6();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__5"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__5__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3293:1: rule__TaskDeclaration__Group__5__Impl : ( RULE_COMMA ) ;
+ public final void rule__TaskDeclaration__Group__5__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3297:1: ( ( RULE_COMMA ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3298:1: ( RULE_COMMA )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3298:1: ( RULE_COMMA )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3299:1: RULE_COMMA
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_5());
+ }
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__TaskDeclaration__Group__5__Impl7269); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_5());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__5__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__6"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3310:1: rule__TaskDeclaration__Group__6 : rule__TaskDeclaration__Group__6__Impl rule__TaskDeclaration__Group__7 ;
+ public final void rule__TaskDeclaration__Group__6() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3314:1: ( rule__TaskDeclaration__Group__6__Impl rule__TaskDeclaration__Group__7 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3315:2: rule__TaskDeclaration__Group__6__Impl rule__TaskDeclaration__Group__7
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__6__Impl_in_rule__TaskDeclaration__Group__67298);
+ rule__TaskDeclaration__Group__6__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__7_in_rule__TaskDeclaration__Group__67301);
+ rule__TaskDeclaration__Group__7();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__6"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__6__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3322:1: rule__TaskDeclaration__Group__6__Impl : ( ( rule__TaskDeclaration__Group_6__0 )? ) ;
+ public final void rule__TaskDeclaration__Group__6__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3326:1: ( ( ( rule__TaskDeclaration__Group_6__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3327:1: ( ( rule__TaskDeclaration__Group_6__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3327:1: ( ( rule__TaskDeclaration__Group_6__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3328:1: ( rule__TaskDeclaration__Group_6__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getGroup_6());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3329:1: ( rule__TaskDeclaration__Group_6__0 )?
+ int alt46=2;
+ int LA46_0 = input.LA(1);
+
+ if ( (LA46_0==RULE_PARAM_START) ) {
+ alt46=1;
+ }
+ switch (alt46) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3329:2: rule__TaskDeclaration__Group_6__0
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group_6__0_in_rule__TaskDeclaration__Group__6__Impl7328);
+ rule__TaskDeclaration__Group_6__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getGroup_6());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__6__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__7"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3339:1: rule__TaskDeclaration__Group__7 : rule__TaskDeclaration__Group__7__Impl rule__TaskDeclaration__Group__8 ;
+ public final void rule__TaskDeclaration__Group__7() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3343:1: ( rule__TaskDeclaration__Group__7__Impl rule__TaskDeclaration__Group__8 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3344:2: rule__TaskDeclaration__Group__7__Impl rule__TaskDeclaration__Group__8
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__7__Impl_in_rule__TaskDeclaration__Group__77359);
+ rule__TaskDeclaration__Group__7__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__8_in_rule__TaskDeclaration__Group__77362);
+ rule__TaskDeclaration__Group__8();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__7"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__7__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3351:1: rule__TaskDeclaration__Group__7__Impl : ( RULE_FUNC_ARROW ) ;
+ public final void rule__TaskDeclaration__Group__7__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3355:1: ( ( RULE_FUNC_ARROW ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3356:1: ( RULE_FUNC_ARROW )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3356:1: ( RULE_FUNC_ARROW )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3357:1: RULE_FUNC_ARROW
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getFUNC_ARROWTerminalRuleCall_7());
+ }
+ match(input,RULE_FUNC_ARROW,FOLLOW_RULE_FUNC_ARROW_in_rule__TaskDeclaration__Group__7__Impl7389); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getFUNC_ARROWTerminalRuleCall_7());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__7__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__8"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3368:1: rule__TaskDeclaration__Group__8 : rule__TaskDeclaration__Group__8__Impl rule__TaskDeclaration__Group__9 ;
+ public final void rule__TaskDeclaration__Group__8() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3372:1: ( rule__TaskDeclaration__Group__8__Impl rule__TaskDeclaration__Group__9 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3373:2: rule__TaskDeclaration__Group__8__Impl rule__TaskDeclaration__Group__9
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__8__Impl_in_rule__TaskDeclaration__Group__87418);
+ rule__TaskDeclaration__Group__8__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__9_in_rule__TaskDeclaration__Group__87421);
+ rule__TaskDeclaration__Group__9();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__8"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__8__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3380:1: rule__TaskDeclaration__Group__8__Impl : ( ( rule__TaskDeclaration__BodyAssignment_8 ) ) ;
+ public final void rule__TaskDeclaration__Group__8__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3384:1: ( ( ( rule__TaskDeclaration__BodyAssignment_8 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3385:1: ( ( rule__TaskDeclaration__BodyAssignment_8 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3385:1: ( ( rule__TaskDeclaration__BodyAssignment_8 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3386:1: ( rule__TaskDeclaration__BodyAssignment_8 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getBodyAssignment_8());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3387:1: ( rule__TaskDeclaration__BodyAssignment_8 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3387:2: rule__TaskDeclaration__BodyAssignment_8
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__BodyAssignment_8_in_rule__TaskDeclaration__Group__8__Impl7448);
+ rule__TaskDeclaration__BodyAssignment_8();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getBodyAssignment_8());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__8__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__9"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3397:1: rule__TaskDeclaration__Group__9 : rule__TaskDeclaration__Group__9__Impl rule__TaskDeclaration__Group__10 ;
+ public final void rule__TaskDeclaration__Group__9() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3401:1: ( rule__TaskDeclaration__Group__9__Impl rule__TaskDeclaration__Group__10 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3402:2: rule__TaskDeclaration__Group__9__Impl rule__TaskDeclaration__Group__10
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__9__Impl_in_rule__TaskDeclaration__Group__97478);
+ rule__TaskDeclaration__Group__9__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__10_in_rule__TaskDeclaration__Group__97481);
+ rule__TaskDeclaration__Group__10();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__9"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__9__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3409:1: rule__TaskDeclaration__Group__9__Impl : ( RULE_CALL_END ) ;
+ public final void rule__TaskDeclaration__Group__9__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3413:1: ( ( RULE_CALL_END ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3414:1: ( RULE_CALL_END )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3414:1: ( RULE_CALL_END )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3415:1: RULE_CALL_END
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getCALL_ENDTerminalRuleCall_9());
+ }
+ match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_rule__TaskDeclaration__Group__9__Impl7508); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getCALL_ENDTerminalRuleCall_9());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__9__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__10"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3426:1: rule__TaskDeclaration__Group__10 : rule__TaskDeclaration__Group__10__Impl ;
+ public final void rule__TaskDeclaration__Group__10() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3430:1: ( rule__TaskDeclaration__Group__10__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3431:2: rule__TaskDeclaration__Group__10__Impl
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group__10__Impl_in_rule__TaskDeclaration__Group__107537);
+ rule__TaskDeclaration__Group__10__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__10"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group__10__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3437:1: rule__TaskDeclaration__Group__10__Impl : ( RULE_TERMINATOR ) ;
+ public final void rule__TaskDeclaration__Group__10__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3441:1: ( ( RULE_TERMINATOR ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3442:1: ( RULE_TERMINATOR )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3442:1: ( RULE_TERMINATOR )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3443:1: RULE_TERMINATOR
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getTERMINATORTerminalRuleCall_10());
+ }
+ match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_rule__TaskDeclaration__Group__10__Impl7564); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getTERMINATORTerminalRuleCall_10());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group__10__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group_6__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3476:1: rule__TaskDeclaration__Group_6__0 : rule__TaskDeclaration__Group_6__0__Impl rule__TaskDeclaration__Group_6__1 ;
+ public final void rule__TaskDeclaration__Group_6__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3480:1: ( rule__TaskDeclaration__Group_6__0__Impl rule__TaskDeclaration__Group_6__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3481:2: rule__TaskDeclaration__Group_6__0__Impl rule__TaskDeclaration__Group_6__1
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group_6__0__Impl_in_rule__TaskDeclaration__Group_6__07615);
+ rule__TaskDeclaration__Group_6__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group_6__1_in_rule__TaskDeclaration__Group_6__07618);
+ rule__TaskDeclaration__Group_6__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group_6__0"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group_6__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3488:1: rule__TaskDeclaration__Group_6__0__Impl : ( RULE_PARAM_START ) ;
+ public final void rule__TaskDeclaration__Group_6__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3492:1: ( ( RULE_PARAM_START ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3493:1: ( RULE_PARAM_START )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3493:1: ( RULE_PARAM_START )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3494:1: RULE_PARAM_START
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getPARAM_STARTTerminalRuleCall_6_0());
+ }
+ match(input,RULE_PARAM_START,FOLLOW_RULE_PARAM_START_in_rule__TaskDeclaration__Group_6__0__Impl7645); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getPARAM_STARTTerminalRuleCall_6_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group_6__0__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group_6__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3505:1: rule__TaskDeclaration__Group_6__1 : rule__TaskDeclaration__Group_6__1__Impl rule__TaskDeclaration__Group_6__2 ;
+ public final void rule__TaskDeclaration__Group_6__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3509:1: ( rule__TaskDeclaration__Group_6__1__Impl rule__TaskDeclaration__Group_6__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3510:2: rule__TaskDeclaration__Group_6__1__Impl rule__TaskDeclaration__Group_6__2
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group_6__1__Impl_in_rule__TaskDeclaration__Group_6__17674);
+ rule__TaskDeclaration__Group_6__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group_6__2_in_rule__TaskDeclaration__Group_6__17677);
+ rule__TaskDeclaration__Group_6__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group_6__1"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group_6__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3517:1: rule__TaskDeclaration__Group_6__1__Impl : ( ( rule__TaskDeclaration__OptionsAssignment_6_1 ) ) ;
+ public final void rule__TaskDeclaration__Group_6__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3521:1: ( ( ( rule__TaskDeclaration__OptionsAssignment_6_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3522:1: ( ( rule__TaskDeclaration__OptionsAssignment_6_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3522:1: ( ( rule__TaskDeclaration__OptionsAssignment_6_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3523:1: ( rule__TaskDeclaration__OptionsAssignment_6_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getOptionsAssignment_6_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3524:1: ( rule__TaskDeclaration__OptionsAssignment_6_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3524:2: rule__TaskDeclaration__OptionsAssignment_6_1
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__OptionsAssignment_6_1_in_rule__TaskDeclaration__Group_6__1__Impl7704);
+ rule__TaskDeclaration__OptionsAssignment_6_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getOptionsAssignment_6_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group_6__1__Impl"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group_6__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3534:1: rule__TaskDeclaration__Group_6__2 : rule__TaskDeclaration__Group_6__2__Impl ;
+ public final void rule__TaskDeclaration__Group_6__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3538:1: ( rule__TaskDeclaration__Group_6__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3539:2: rule__TaskDeclaration__Group_6__2__Impl
+ {
+ pushFollow(FOLLOW_rule__TaskDeclaration__Group_6__2__Impl_in_rule__TaskDeclaration__Group_6__27734);
+ rule__TaskDeclaration__Group_6__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group_6__2"
+
+
+ // $ANTLR start "rule__TaskDeclaration__Group_6__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3545:1: rule__TaskDeclaration__Group_6__2__Impl : ( RULE_PARAM_END ) ;
+ public final void rule__TaskDeclaration__Group_6__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3549:1: ( ( RULE_PARAM_END ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3550:1: ( RULE_PARAM_END )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3550:1: ( RULE_PARAM_END )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3551:1: RULE_PARAM_END
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getPARAM_ENDTerminalRuleCall_6_2());
+ }
+ match(input,RULE_PARAM_END,FOLLOW_RULE_PARAM_END_in_rule__TaskDeclaration__Group_6__2__Impl7761); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getPARAM_ENDTerminalRuleCall_6_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__Group_6__2__Impl"
+
+
+ // $ANTLR start "rule__Body__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3569:1: rule__Body__Group__0 : rule__Body__Group__0__Impl rule__Body__Group__1 ;
+ public final void rule__Body__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3573:1: ( rule__Body__Group__0__Impl rule__Body__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3574:2: rule__Body__Group__0__Impl rule__Body__Group__1
+ {
+ pushFollow(FOLLOW_rule__Body__Group__0__Impl_in_rule__Body__Group__07797);
+ rule__Body__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Body__Group__1_in_rule__Body__Group__07800);
+ rule__Body__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__Group__0"
+
+
+ // $ANTLR start "rule__Body__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3581:1: rule__Body__Group__0__Impl : ( ( rule__Body__LinesAssignment_0 ) ) ;
+ public final void rule__Body__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3585:1: ( ( ( rule__Body__LinesAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3586:1: ( ( rule__Body__LinesAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3586:1: ( ( rule__Body__LinesAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3587:1: ( rule__Body__LinesAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBodyAccess().getLinesAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3588:1: ( rule__Body__LinesAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3588:2: rule__Body__LinesAssignment_0
+ {
+ pushFollow(FOLLOW_rule__Body__LinesAssignment_0_in_rule__Body__Group__0__Impl7827);
+ rule__Body__LinesAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBodyAccess().getLinesAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Body__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3598:1: rule__Body__Group__1 : rule__Body__Group__1__Impl ;
+ public final void rule__Body__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3602:1: ( rule__Body__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3603:2: rule__Body__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Body__Group__1__Impl_in_rule__Body__Group__17857);
+ rule__Body__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__Group__1"
+
+
+ // $ANTLR start "rule__Body__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3609:1: rule__Body__Group__1__Impl : ( ( rule__Body__Group_1__0 )* ) ;
+ public final void rule__Body__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3613:1: ( ( ( rule__Body__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3614:1: ( ( rule__Body__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3614:1: ( ( rule__Body__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3615:1: ( rule__Body__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBodyAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3616:1: ( rule__Body__Group_1__0 )*
+ loop47:
+ do {
+ int alt47=2;
+ int LA47_0 = input.LA(1);
+
+ if ( (LA47_0==RULE_TERMINATOR) ) {
+ alt47=1;
+ }
+
+
+ switch (alt47) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3616:2: rule__Body__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__Body__Group_1__0_in_rule__Body__Group__1__Impl7884);
+ rule__Body__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop47;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBodyAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Body__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3630:1: rule__Body__Group_1__0 : rule__Body__Group_1__0__Impl rule__Body__Group_1__1 ;
+ public final void rule__Body__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3634:1: ( rule__Body__Group_1__0__Impl rule__Body__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3635:2: rule__Body__Group_1__0__Impl rule__Body__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__Body__Group_1__0__Impl_in_rule__Body__Group_1__07919);
+ rule__Body__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Body__Group_1__1_in_rule__Body__Group_1__07922);
+ rule__Body__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__Group_1__0"
+
+
+ // $ANTLR start "rule__Body__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3642:1: rule__Body__Group_1__0__Impl : ( RULE_TERMINATOR ) ;
+ public final void rule__Body__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3646:1: ( ( RULE_TERMINATOR ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3647:1: ( RULE_TERMINATOR )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3647:1: ( RULE_TERMINATOR )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3648:1: RULE_TERMINATOR
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0());
+ }
+ match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_rule__Body__Group_1__0__Impl7949); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__Body__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3659:1: rule__Body__Group_1__1 : rule__Body__Group_1__1__Impl ;
+ public final void rule__Body__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3663:1: ( rule__Body__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3664:2: rule__Body__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Body__Group_1__1__Impl_in_rule__Body__Group_1__17978);
+ rule__Body__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__Group_1__1"
+
+
+ // $ANTLR start "rule__Body__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3670:1: rule__Body__Group_1__1__Impl : ( ( rule__Body__LinesAssignment_1_1 )? ) ;
+ public final void rule__Body__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3674:1: ( ( ( rule__Body__LinesAssignment_1_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3675:1: ( ( rule__Body__LinesAssignment_1_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3675:1: ( ( rule__Body__LinesAssignment_1_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3676:1: ( rule__Body__LinesAssignment_1_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBodyAccess().getLinesAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3677:1: ( rule__Body__LinesAssignment_1_1 )?
+ int alt48=2;
+ int LA48_0 = input.LA(1);
+
+ if ( ((LA48_0>=RULE_PLUS && LA48_0<=RULE_MINUS_MINUS)||(LA48_0>=RULE_AT_SIGIL && LA48_0<=RULE_BOUND_FUNC_ARROW)||LA48_0==RULE_PARAM_START||LA48_0==RULE_RETURN||(LA48_0>=RULE_THROW && LA48_0<=RULE_CLASS)||(LA48_0>=RULE_FOR && LA48_0<=RULE_WHILE)||LA48_0==RULE_UNTIL||LA48_0==RULE_LBRACKET||LA48_0==RULE_SUPER||(LA48_0>=RULE_THIS && LA48_0<=RULE_TRY)||LA48_0==RULE_SWITCH||LA48_0==RULE_LCURLY||(LA48_0>=RULE_NUMBER && LA48_0<=RULE_REGEX)||(LA48_0>=RULE_LPAREN && LA48_0<=RULE_HERECOMMENT)||(LA48_0>=RULE_IF && LA48_0<=RULE_IDENTIFIER)) ) {
+ alt48=1;
+ }
+ switch (alt48) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3677:2: rule__Body__LinesAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__Body__LinesAssignment_1_1_in_rule__Body__Group_1__1__Impl8005);
+ rule__Body__LinesAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBodyAccess().getLinesAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__RequireStmt__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3691:1: rule__RequireStmt__Group__0 : rule__RequireStmt__Group__0__Impl rule__RequireStmt__Group__1 ;
+ public final void rule__RequireStmt__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3695:1: ( rule__RequireStmt__Group__0__Impl rule__RequireStmt__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3696:2: rule__RequireStmt__Group__0__Impl rule__RequireStmt__Group__1
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group__0__Impl_in_rule__RequireStmt__Group__08040);
+ rule__RequireStmt__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__RequireStmt__Group__1_in_rule__RequireStmt__Group__08043);
+ rule__RequireStmt__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group__0"
+
+
+ // $ANTLR start "rule__RequireStmt__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3703:1: rule__RequireStmt__Group__0__Impl : ( ( rule__RequireStmt__Group_0__0 ) ) ;
+ public final void rule__RequireStmt__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3707:1: ( ( ( rule__RequireStmt__Group_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3708:1: ( ( rule__RequireStmt__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3708:1: ( ( rule__RequireStmt__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3709:1: ( rule__RequireStmt__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3710:1: ( rule__RequireStmt__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3710:2: rule__RequireStmt__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group_0__0_in_rule__RequireStmt__Group__0__Impl8070);
+ rule__RequireStmt__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group__0__Impl"
+
+
+ // $ANTLR start "rule__RequireStmt__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3720:1: rule__RequireStmt__Group__1 : rule__RequireStmt__Group__1__Impl rule__RequireStmt__Group__2 ;
+ public final void rule__RequireStmt__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3724:1: ( rule__RequireStmt__Group__1__Impl rule__RequireStmt__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3725:2: rule__RequireStmt__Group__1__Impl rule__RequireStmt__Group__2
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group__1__Impl_in_rule__RequireStmt__Group__18100);
+ rule__RequireStmt__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__RequireStmt__Group__2_in_rule__RequireStmt__Group__18103);
+ rule__RequireStmt__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group__1"
+
+
+ // $ANTLR start "rule__RequireStmt__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3732:1: rule__RequireStmt__Group__1__Impl : ( RULE_CALL_START ) ;
+ public final void rule__RequireStmt__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3736:1: ( ( RULE_CALL_START ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3737:1: ( RULE_CALL_START )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3737:1: ( RULE_CALL_START )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3738:1: RULE_CALL_START
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1());
+ }
+ match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_rule__RequireStmt__Group__1__Impl8130); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group__1__Impl"
+
+
+ // $ANTLR start "rule__RequireStmt__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3749:1: rule__RequireStmt__Group__2 : rule__RequireStmt__Group__2__Impl rule__RequireStmt__Group__3 ;
+ public final void rule__RequireStmt__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3753:1: ( rule__RequireStmt__Group__2__Impl rule__RequireStmt__Group__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3754:2: rule__RequireStmt__Group__2__Impl rule__RequireStmt__Group__3
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group__2__Impl_in_rule__RequireStmt__Group__28159);
+ rule__RequireStmt__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__RequireStmt__Group__3_in_rule__RequireStmt__Group__28162);
+ rule__RequireStmt__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group__2"
+
+
+ // $ANTLR start "rule__RequireStmt__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3761:1: rule__RequireStmt__Group__2__Impl : ( ( rule__RequireStmt__UriAssignment_2 ) ) ;
+ public final void rule__RequireStmt__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3765:1: ( ( ( rule__RequireStmt__UriAssignment_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3766:1: ( ( rule__RequireStmt__UriAssignment_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3766:1: ( ( rule__RequireStmt__UriAssignment_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3767:1: ( rule__RequireStmt__UriAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getUriAssignment_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3768:1: ( rule__RequireStmt__UriAssignment_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3768:2: rule__RequireStmt__UriAssignment_2
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__UriAssignment_2_in_rule__RequireStmt__Group__2__Impl8189);
+ rule__RequireStmt__UriAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getUriAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group__2__Impl"
+
+
+ // $ANTLR start "rule__RequireStmt__Group__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3778:1: rule__RequireStmt__Group__3 : rule__RequireStmt__Group__3__Impl ;
+ public final void rule__RequireStmt__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3782:1: ( rule__RequireStmt__Group__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3783:2: rule__RequireStmt__Group__3__Impl
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group__3__Impl_in_rule__RequireStmt__Group__38219);
+ rule__RequireStmt__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group__3"
+
+
+ // $ANTLR start "rule__RequireStmt__Group__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3789:1: rule__RequireStmt__Group__3__Impl : ( RULE_CALL_END ) ;
+ public final void rule__RequireStmt__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3793:1: ( ( RULE_CALL_END ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3794:1: ( RULE_CALL_END )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3794:1: ( RULE_CALL_END )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3795:1: RULE_CALL_END
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3());
+ }
+ match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_rule__RequireStmt__Group__3__Impl8246); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group__3__Impl"
+
+
+ // $ANTLR start "rule__RequireStmt__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3814:1: rule__RequireStmt__Group_0__0 : rule__RequireStmt__Group_0__0__Impl ;
+ public final void rule__RequireStmt__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3818:1: ( rule__RequireStmt__Group_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3819:2: rule__RequireStmt__Group_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group_0__0__Impl_in_rule__RequireStmt__Group_0__08283);
+ rule__RequireStmt__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group_0__0"
+
+
+ // $ANTLR start "rule__RequireStmt__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3825:1: rule__RequireStmt__Group_0__0__Impl : ( ( rule__RequireStmt__Group_0_0__0 ) ) ;
+ public final void rule__RequireStmt__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3829:1: ( ( ( rule__RequireStmt__Group_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3830:1: ( ( rule__RequireStmt__Group_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3830:1: ( ( rule__RequireStmt__Group_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3831:1: ( rule__RequireStmt__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getGroup_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3832:1: ( rule__RequireStmt__Group_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3832:2: rule__RequireStmt__Group_0_0__0
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group_0_0__0_in_rule__RequireStmt__Group_0__0__Impl8310);
+ rule__RequireStmt__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__RequireStmt__Group_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3844:1: rule__RequireStmt__Group_0_0__0 : rule__RequireStmt__Group_0_0__0__Impl rule__RequireStmt__Group_0_0__1 ;
+ public final void rule__RequireStmt__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3848:1: ( rule__RequireStmt__Group_0_0__0__Impl rule__RequireStmt__Group_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3849:2: rule__RequireStmt__Group_0_0__0__Impl rule__RequireStmt__Group_0_0__1
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group_0_0__0__Impl_in_rule__RequireStmt__Group_0_0__08342);
+ rule__RequireStmt__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__RequireStmt__Group_0_0__1_in_rule__RequireStmt__Group_0_0__08345);
+ rule__RequireStmt__Group_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group_0_0__0"
+
+
+ // $ANTLR start "rule__RequireStmt__Group_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3856:1: rule__RequireStmt__Group_0_0__0__Impl : ( ( rule__RequireStmt__ImportedNamespaceAssignment_0_0_0 ) ) ;
+ public final void rule__RequireStmt__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3860:1: ( ( ( rule__RequireStmt__ImportedNamespaceAssignment_0_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3861:1: ( ( rule__RequireStmt__ImportedNamespaceAssignment_0_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3861:1: ( ( rule__RequireStmt__ImportedNamespaceAssignment_0_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3862:1: ( rule__RequireStmt__ImportedNamespaceAssignment_0_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getImportedNamespaceAssignment_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3863:1: ( rule__RequireStmt__ImportedNamespaceAssignment_0_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3863:2: rule__RequireStmt__ImportedNamespaceAssignment_0_0_0
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__ImportedNamespaceAssignment_0_0_0_in_rule__RequireStmt__Group_0_0__0__Impl8372);
+ rule__RequireStmt__ImportedNamespaceAssignment_0_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getImportedNamespaceAssignment_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__RequireStmt__Group_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3873:1: rule__RequireStmt__Group_0_0__1 : rule__RequireStmt__Group_0_0__1__Impl rule__RequireStmt__Group_0_0__2 ;
+ public final void rule__RequireStmt__Group_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3877:1: ( rule__RequireStmt__Group_0_0__1__Impl rule__RequireStmt__Group_0_0__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3878:2: rule__RequireStmt__Group_0_0__1__Impl rule__RequireStmt__Group_0_0__2
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group_0_0__1__Impl_in_rule__RequireStmt__Group_0_0__18402);
+ rule__RequireStmt__Group_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__RequireStmt__Group_0_0__2_in_rule__RequireStmt__Group_0_0__18405);
+ rule__RequireStmt__Group_0_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group_0_0__1"
+
+
+ // $ANTLR start "rule__RequireStmt__Group_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3885:1: rule__RequireStmt__Group_0_0__1__Impl : ( RULE_EQUAL ) ;
+ public final void rule__RequireStmt__Group_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3889:1: ( ( RULE_EQUAL ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3890:1: ( RULE_EQUAL )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3890:1: ( RULE_EQUAL )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3891:1: RULE_EQUAL
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1());
+ }
+ match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_rule__RequireStmt__Group_0_0__1__Impl8432); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__RequireStmt__Group_0_0__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3902:1: rule__RequireStmt__Group_0_0__2 : rule__RequireStmt__Group_0_0__2__Impl ;
+ public final void rule__RequireStmt__Group_0_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3906:1: ( rule__RequireStmt__Group_0_0__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3907:2: rule__RequireStmt__Group_0_0__2__Impl
+ {
+ pushFollow(FOLLOW_rule__RequireStmt__Group_0_0__2__Impl_in_rule__RequireStmt__Group_0_0__28461);
+ rule__RequireStmt__Group_0_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group_0_0__2"
+
+
+ // $ANTLR start "rule__RequireStmt__Group_0_0__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3913:1: rule__RequireStmt__Group_0_0__2__Impl : ( 'require' ) ;
+ public final void rule__RequireStmt__Group_0_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3917:1: ( ( 'require' ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3918:1: ( 'require' )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3918:1: ( 'require' )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3919:1: 'require'
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2());
+ }
+ match(input,86,FOLLOW_86_in_rule__RequireStmt__Group_0_0__2__Impl8489); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__Group_0_0__2__Impl"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3938:1: rule__ReturnStmt__Group__0 : rule__ReturnStmt__Group__0__Impl rule__ReturnStmt__Group__1 ;
+ public final void rule__ReturnStmt__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3942:1: ( rule__ReturnStmt__Group__0__Impl rule__ReturnStmt__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3943:2: rule__ReturnStmt__Group__0__Impl rule__ReturnStmt__Group__1
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__Group__0__Impl_in_rule__ReturnStmt__Group__08526);
+ rule__ReturnStmt__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ReturnStmt__Group__1_in_rule__ReturnStmt__Group__08529);
+ rule__ReturnStmt__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group__0"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3950:1: rule__ReturnStmt__Group__0__Impl : ( () ) ;
+ public final void rule__ReturnStmt__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3954:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3955:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3955:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3956:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtAccess().getReturnStmtAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3957:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3959:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtAccess().getReturnStmtAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3969:1: rule__ReturnStmt__Group__1 : rule__ReturnStmt__Group__1__Impl rule__ReturnStmt__Group__2 ;
+ public final void rule__ReturnStmt__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3973:1: ( rule__ReturnStmt__Group__1__Impl rule__ReturnStmt__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3974:2: rule__ReturnStmt__Group__1__Impl rule__ReturnStmt__Group__2
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__Group__1__Impl_in_rule__ReturnStmt__Group__18587);
+ rule__ReturnStmt__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ReturnStmt__Group__2_in_rule__ReturnStmt__Group__18590);
+ rule__ReturnStmt__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group__1"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3981:1: rule__ReturnStmt__Group__1__Impl : ( RULE_RETURN ) ;
+ public final void rule__ReturnStmt__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3985:1: ( ( RULE_RETURN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3986:1: ( RULE_RETURN )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3986:1: ( RULE_RETURN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3987:1: RULE_RETURN
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1());
+ }
+ match(input,RULE_RETURN,FOLLOW_RULE_RETURN_in_rule__ReturnStmt__Group__1__Impl8617); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:3998:1: rule__ReturnStmt__Group__2 : rule__ReturnStmt__Group__2__Impl rule__ReturnStmt__Group__3 ;
+ public final void rule__ReturnStmt__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4002:1: ( rule__ReturnStmt__Group__2__Impl rule__ReturnStmt__Group__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4003:2: rule__ReturnStmt__Group__2__Impl rule__ReturnStmt__Group__3
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__Group__2__Impl_in_rule__ReturnStmt__Group__28646);
+ rule__ReturnStmt__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ReturnStmt__Group__3_in_rule__ReturnStmt__Group__28649);
+ rule__ReturnStmt__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group__2"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4010:1: rule__ReturnStmt__Group__2__Impl : ( ( rule__ReturnStmt__ExpressionAssignment_2 )? ) ;
+ public final void rule__ReturnStmt__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4014:1: ( ( ( rule__ReturnStmt__ExpressionAssignment_2 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4015:1: ( ( rule__ReturnStmt__ExpressionAssignment_2 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4015:1: ( ( rule__ReturnStmt__ExpressionAssignment_2 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4016:1: ( rule__ReturnStmt__ExpressionAssignment_2 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtAccess().getExpressionAssignment_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4017:1: ( rule__ReturnStmt__ExpressionAssignment_2 )?
+ int alt49=2;
+ int LA49_0 = input.LA(1);
+
+ if ( ((LA49_0>=RULE_PLUS && LA49_0<=RULE_MINUS_MINUS)||(LA49_0>=RULE_AT_SIGIL && LA49_0<=RULE_BOUND_FUNC_ARROW)||LA49_0==RULE_PARAM_START||(LA49_0>=RULE_FOR && LA49_0<=RULE_WHILE)||LA49_0==RULE_UNTIL||LA49_0==RULE_LBRACKET||LA49_0==RULE_SUPER||(LA49_0>=RULE_THIS && LA49_0<=RULE_TRY)||LA49_0==RULE_SWITCH||LA49_0==RULE_LCURLY||(LA49_0>=RULE_NUMBER && LA49_0<=RULE_REGEX)||LA49_0==RULE_LPAREN||(LA49_0>=RULE_IF && LA49_0<=RULE_IDENTIFIER)) ) {
+ alt49=1;
+ }
+ switch (alt49) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4017:2: rule__ReturnStmt__ExpressionAssignment_2
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__ExpressionAssignment_2_in_rule__ReturnStmt__Group__2__Impl8676);
+ rule__ReturnStmt__ExpressionAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtAccess().getExpressionAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group__2__Impl"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4027:1: rule__ReturnStmt__Group__3 : rule__ReturnStmt__Group__3__Impl ;
+ public final void rule__ReturnStmt__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4031:1: ( rule__ReturnStmt__Group__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4032:2: rule__ReturnStmt__Group__3__Impl
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__Group__3__Impl_in_rule__ReturnStmt__Group__38707);
+ rule__ReturnStmt__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group__3"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4038:1: rule__ReturnStmt__Group__3__Impl : ( ( rule__ReturnStmt__Group_3__0 )? ) ;
+ public final void rule__ReturnStmt__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4042:1: ( ( ( rule__ReturnStmt__Group_3__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4043:1: ( ( rule__ReturnStmt__Group_3__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4043:1: ( ( rule__ReturnStmt__Group_3__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4044:1: ( rule__ReturnStmt__Group_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtAccess().getGroup_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4045:1: ( rule__ReturnStmt__Group_3__0 )?
+ int alt50=2;
+ int LA50_0 = input.LA(1);
+
+ if ( (LA50_0==RULE_POST_IF) ) {
+ alt50=1;
+ }
+ switch (alt50) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4045:2: rule__ReturnStmt__Group_3__0
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__Group_3__0_in_rule__ReturnStmt__Group__3__Impl8734);
+ rule__ReturnStmt__Group_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtAccess().getGroup_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group__3__Impl"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group_3__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4063:1: rule__ReturnStmt__Group_3__0 : rule__ReturnStmt__Group_3__0__Impl rule__ReturnStmt__Group_3__1 ;
+ public final void rule__ReturnStmt__Group_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4067:1: ( rule__ReturnStmt__Group_3__0__Impl rule__ReturnStmt__Group_3__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4068:2: rule__ReturnStmt__Group_3__0__Impl rule__ReturnStmt__Group_3__1
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__Group_3__0__Impl_in_rule__ReturnStmt__Group_3__08773);
+ rule__ReturnStmt__Group_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ReturnStmt__Group_3__1_in_rule__ReturnStmt__Group_3__08776);
+ rule__ReturnStmt__Group_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group_3__0"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group_3__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4075:1: rule__ReturnStmt__Group_3__0__Impl : ( RULE_POST_IF ) ;
+ public final void rule__ReturnStmt__Group_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4079:1: ( ( RULE_POST_IF ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4080:1: ( RULE_POST_IF )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4080:1: ( RULE_POST_IF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4081:1: RULE_POST_IF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0());
+ }
+ match(input,RULE_POST_IF,FOLLOW_RULE_POST_IF_in_rule__ReturnStmt__Group_3__0__Impl8803); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group_3__0__Impl"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group_3__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4092:1: rule__ReturnStmt__Group_3__1 : rule__ReturnStmt__Group_3__1__Impl ;
+ public final void rule__ReturnStmt__Group_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4096:1: ( rule__ReturnStmt__Group_3__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4097:2: rule__ReturnStmt__Group_3__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__Group_3__1__Impl_in_rule__ReturnStmt__Group_3__18832);
+ rule__ReturnStmt__Group_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group_3__1"
+
+
+ // $ANTLR start "rule__ReturnStmt__Group_3__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4103:1: rule__ReturnStmt__Group_3__1__Impl : ( ( rule__ReturnStmt__ConditionAssignment_3_1 ) ) ;
+ public final void rule__ReturnStmt__Group_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4107:1: ( ( ( rule__ReturnStmt__ConditionAssignment_3_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4108:1: ( ( rule__ReturnStmt__ConditionAssignment_3_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4108:1: ( ( rule__ReturnStmt__ConditionAssignment_3_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4109:1: ( rule__ReturnStmt__ConditionAssignment_3_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtAccess().getConditionAssignment_3_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4110:1: ( rule__ReturnStmt__ConditionAssignment_3_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4110:2: rule__ReturnStmt__ConditionAssignment_3_1
+ {
+ pushFollow(FOLLOW_rule__ReturnStmt__ConditionAssignment_3_1_in_rule__ReturnStmt__Group_3__1__Impl8859);
+ rule__ReturnStmt__ConditionAssignment_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtAccess().getConditionAssignment_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__Group_3__1__Impl"
+
+
+ // $ANTLR start "rule__ThrowStmt__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4124:1: rule__ThrowStmt__Group__0 : rule__ThrowStmt__Group__0__Impl rule__ThrowStmt__Group__1 ;
+ public final void rule__ThrowStmt__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4128:1: ( rule__ThrowStmt__Group__0__Impl rule__ThrowStmt__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4129:2: rule__ThrowStmt__Group__0__Impl rule__ThrowStmt__Group__1
+ {
+ pushFollow(FOLLOW_rule__ThrowStmt__Group__0__Impl_in_rule__ThrowStmt__Group__08893);
+ rule__ThrowStmt__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ThrowStmt__Group__1_in_rule__ThrowStmt__Group__08896);
+ rule__ThrowStmt__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ThrowStmt__Group__0"
+
+
+ // $ANTLR start "rule__ThrowStmt__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4136:1: rule__ThrowStmt__Group__0__Impl : ( RULE_THROW ) ;
+ public final void rule__ThrowStmt__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4140:1: ( ( RULE_THROW ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4141:1: ( RULE_THROW )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4141:1: ( RULE_THROW )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4142:1: RULE_THROW
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0());
+ }
+ match(input,RULE_THROW,FOLLOW_RULE_THROW_in_rule__ThrowStmt__Group__0__Impl8923); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ThrowStmt__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ThrowStmt__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4153:1: rule__ThrowStmt__Group__1 : rule__ThrowStmt__Group__1__Impl ;
+ public final void rule__ThrowStmt__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4157:1: ( rule__ThrowStmt__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4158:2: rule__ThrowStmt__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ThrowStmt__Group__1__Impl_in_rule__ThrowStmt__Group__18952);
+ rule__ThrowStmt__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ThrowStmt__Group__1"
+
+
+ // $ANTLR start "rule__ThrowStmt__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4164:1: rule__ThrowStmt__Group__1__Impl : ( ( rule__ThrowStmt__ExpAssignment_1 ) ) ;
+ public final void rule__ThrowStmt__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4168:1: ( ( ( rule__ThrowStmt__ExpAssignment_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4169:1: ( ( rule__ThrowStmt__ExpAssignment_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4169:1: ( ( rule__ThrowStmt__ExpAssignment_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4170:1: ( rule__ThrowStmt__ExpAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getThrowStmtAccess().getExpAssignment_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4171:1: ( rule__ThrowStmt__ExpAssignment_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4171:2: rule__ThrowStmt__ExpAssignment_1
+ {
+ pushFollow(FOLLOW_rule__ThrowStmt__ExpAssignment_1_in_rule__ThrowStmt__Group__1__Impl8979);
+ rule__ThrowStmt__ExpAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getThrowStmtAccess().getExpAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ThrowStmt__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4185:1: rule__ClassDeclaration__Group__0 : rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 ;
+ public final void rule__ClassDeclaration__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4189:1: ( rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4190:2: rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group__0__Impl_in_rule__ClassDeclaration__Group__09013);
+ rule__ClassDeclaration__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group__1_in_rule__ClassDeclaration__Group__09016);
+ rule__ClassDeclaration__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group__0"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4197:1: rule__ClassDeclaration__Group__0__Impl : ( () ) ;
+ public final void rule__ClassDeclaration__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4201:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4202:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4202:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4203:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4204:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4206:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4216:1: rule__ClassDeclaration__Group__1 : rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 ;
+ public final void rule__ClassDeclaration__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4220:1: ( rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4221:2: rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group__1__Impl_in_rule__ClassDeclaration__Group__19074);
+ rule__ClassDeclaration__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group__2_in_rule__ClassDeclaration__Group__19077);
+ rule__ClassDeclaration__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group__1"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4228:1: rule__ClassDeclaration__Group__1__Impl : ( RULE_CLASS ) ;
+ public final void rule__ClassDeclaration__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4232:1: ( ( RULE_CLASS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4233:1: ( RULE_CLASS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4233:1: ( RULE_CLASS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4234:1: RULE_CLASS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+ }
+ match(input,RULE_CLASS,FOLLOW_RULE_CLASS_in_rule__ClassDeclaration__Group__1__Impl9104); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4245:1: rule__ClassDeclaration__Group__2 : rule__ClassDeclaration__Group__2__Impl ;
+ public final void rule__ClassDeclaration__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4249:1: ( rule__ClassDeclaration__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4250:2: rule__ClassDeclaration__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group__2__Impl_in_rule__ClassDeclaration__Group__29133);
+ rule__ClassDeclaration__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group__2"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4256:1: rule__ClassDeclaration__Group__2__Impl : ( ( rule__ClassDeclaration__Alternatives_2 )? ) ;
+ public final void rule__ClassDeclaration__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4260:1: ( ( ( rule__ClassDeclaration__Alternatives_2 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4261:1: ( ( rule__ClassDeclaration__Alternatives_2 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4261:1: ( ( rule__ClassDeclaration__Alternatives_2 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4262:1: ( rule__ClassDeclaration__Alternatives_2 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getAlternatives_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4263:1: ( rule__ClassDeclaration__Alternatives_2 )?
+ int alt51=2;
+ int LA51_0 = input.LA(1);
+
+ if ( (LA51_0==RULE_EXTENDS||LA51_0==RULE_INDENT||LA51_0==RULE_IDENTIFIER) ) {
+ alt51=1;
+ }
+ switch (alt51) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4263:2: rule__ClassDeclaration__Alternatives_2
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Alternatives_2_in_rule__ClassDeclaration__Group__2__Impl9160);
+ rule__ClassDeclaration__Alternatives_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getAlternatives_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group__2__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4279:1: rule__ClassDeclaration__Group_2_1__0 : rule__ClassDeclaration__Group_2_1__0__Impl rule__ClassDeclaration__Group_2_1__1 ;
+ public final void rule__ClassDeclaration__Group_2_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4283:1: ( rule__ClassDeclaration__Group_2_1__0__Impl rule__ClassDeclaration__Group_2_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4284:2: rule__ClassDeclaration__Group_2_1__0__Impl rule__ClassDeclaration__Group_2_1__1
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_1__0__Impl_in_rule__ClassDeclaration__Group_2_1__09197);
+ rule__ClassDeclaration__Group_2_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_1__1_in_rule__ClassDeclaration__Group_2_1__09200);
+ rule__ClassDeclaration__Group_2_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_1__0"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4291:1: rule__ClassDeclaration__Group_2_1__0__Impl : ( RULE_EXTENDS ) ;
+ public final void rule__ClassDeclaration__Group_2_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4295:1: ( ( RULE_EXTENDS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4296:1: ( RULE_EXTENDS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4296:1: ( RULE_EXTENDS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4297:1: RULE_EXTENDS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0());
+ }
+ match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_rule__ClassDeclaration__Group_2_1__0__Impl9227); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_1__0__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4308:1: rule__ClassDeclaration__Group_2_1__1 : rule__ClassDeclaration__Group_2_1__1__Impl rule__ClassDeclaration__Group_2_1__2 ;
+ public final void rule__ClassDeclaration__Group_2_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4312:1: ( rule__ClassDeclaration__Group_2_1__1__Impl rule__ClassDeclaration__Group_2_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4313:2: rule__ClassDeclaration__Group_2_1__1__Impl rule__ClassDeclaration__Group_2_1__2
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_1__1__Impl_in_rule__ClassDeclaration__Group_2_1__19256);
+ rule__ClassDeclaration__Group_2_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_1__2_in_rule__ClassDeclaration__Group_2_1__19259);
+ rule__ClassDeclaration__Group_2_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_1__1"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4320:1: rule__ClassDeclaration__Group_2_1__1__Impl : ( ( rule__ClassDeclaration__ExtendAssignment_2_1_1 ) ) ;
+ public final void rule__ClassDeclaration__Group_2_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4324:1: ( ( ( rule__ClassDeclaration__ExtendAssignment_2_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4325:1: ( ( rule__ClassDeclaration__ExtendAssignment_2_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4325:1: ( ( rule__ClassDeclaration__ExtendAssignment_2_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4326:1: ( rule__ClassDeclaration__ExtendAssignment_2_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4327:1: ( rule__ClassDeclaration__ExtendAssignment_2_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4327:2: rule__ClassDeclaration__ExtendAssignment_2_1_1
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__ExtendAssignment_2_1_1_in_rule__ClassDeclaration__Group_2_1__1__Impl9286);
+ rule__ClassDeclaration__ExtendAssignment_2_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_1__1__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4337:1: rule__ClassDeclaration__Group_2_1__2 : rule__ClassDeclaration__Group_2_1__2__Impl ;
+ public final void rule__ClassDeclaration__Group_2_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4341:1: ( rule__ClassDeclaration__Group_2_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4342:2: rule__ClassDeclaration__Group_2_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_1__2__Impl_in_rule__ClassDeclaration__Group_2_1__29316);
+ rule__ClassDeclaration__Group_2_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_1__2"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4348:1: rule__ClassDeclaration__Group_2_1__2__Impl : ( ( rule__ClassDeclaration__BodyAssignment_2_1_2 )? ) ;
+ public final void rule__ClassDeclaration__Group_2_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4352:1: ( ( ( rule__ClassDeclaration__BodyAssignment_2_1_2 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4353:1: ( ( rule__ClassDeclaration__BodyAssignment_2_1_2 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4353:1: ( ( rule__ClassDeclaration__BodyAssignment_2_1_2 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4354:1: ( rule__ClassDeclaration__BodyAssignment_2_1_2 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4355:1: ( rule__ClassDeclaration__BodyAssignment_2_1_2 )?
+ int alt52=2;
+ int LA52_0 = input.LA(1);
+
+ if ( (LA52_0==RULE_INDENT) ) {
+ alt52=1;
+ }
+ switch (alt52) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4355:2: rule__ClassDeclaration__BodyAssignment_2_1_2
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__BodyAssignment_2_1_2_in_rule__ClassDeclaration__Group_2_1__2__Impl9343);
+ rule__ClassDeclaration__BodyAssignment_2_1_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_1__2__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4371:1: rule__ClassDeclaration__Group_2_2__0 : rule__ClassDeclaration__Group_2_2__0__Impl rule__ClassDeclaration__Group_2_2__1 ;
+ public final void rule__ClassDeclaration__Group_2_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4375:1: ( rule__ClassDeclaration__Group_2_2__0__Impl rule__ClassDeclaration__Group_2_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4376:2: rule__ClassDeclaration__Group_2_2__0__Impl rule__ClassDeclaration__Group_2_2__1
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2__0__Impl_in_rule__ClassDeclaration__Group_2_2__09380);
+ rule__ClassDeclaration__Group_2_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2__1_in_rule__ClassDeclaration__Group_2_2__09383);
+ rule__ClassDeclaration__Group_2_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2__0"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4383:1: rule__ClassDeclaration__Group_2_2__0__Impl : ( ( rule__ClassDeclaration__NameAssignment_2_2_0 ) ) ;
+ public final void rule__ClassDeclaration__Group_2_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4387:1: ( ( ( rule__ClassDeclaration__NameAssignment_2_2_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4388:1: ( ( rule__ClassDeclaration__NameAssignment_2_2_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4388:1: ( ( rule__ClassDeclaration__NameAssignment_2_2_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4389:1: ( rule__ClassDeclaration__NameAssignment_2_2_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2_2_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4390:1: ( rule__ClassDeclaration__NameAssignment_2_2_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4390:2: rule__ClassDeclaration__NameAssignment_2_2_0
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__NameAssignment_2_2_0_in_rule__ClassDeclaration__Group_2_2__0__Impl9410);
+ rule__ClassDeclaration__NameAssignment_2_2_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getNameAssignment_2_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2__0__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4400:1: rule__ClassDeclaration__Group_2_2__1 : rule__ClassDeclaration__Group_2_2__1__Impl rule__ClassDeclaration__Group_2_2__2 ;
+ public final void rule__ClassDeclaration__Group_2_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4404:1: ( rule__ClassDeclaration__Group_2_2__1__Impl rule__ClassDeclaration__Group_2_2__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4405:2: rule__ClassDeclaration__Group_2_2__1__Impl rule__ClassDeclaration__Group_2_2__2
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2__1__Impl_in_rule__ClassDeclaration__Group_2_2__19440);
+ rule__ClassDeclaration__Group_2_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2__2_in_rule__ClassDeclaration__Group_2_2__19443);
+ rule__ClassDeclaration__Group_2_2__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2__1"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4412:1: rule__ClassDeclaration__Group_2_2__1__Impl : ( ( rule__ClassDeclaration__Group_2_2_1__0 )? ) ;
+ public final void rule__ClassDeclaration__Group_2_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4416:1: ( ( ( rule__ClassDeclaration__Group_2_2_1__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4417:1: ( ( rule__ClassDeclaration__Group_2_2_1__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4417:1: ( ( rule__ClassDeclaration__Group_2_2_1__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4418:1: ( rule__ClassDeclaration__Group_2_2_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getGroup_2_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4419:1: ( rule__ClassDeclaration__Group_2_2_1__0 )?
+ int alt53=2;
+ int LA53_0 = input.LA(1);
+
+ if ( (LA53_0==RULE_EXTENDS) ) {
+ alt53=1;
+ }
+ switch (alt53) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4419:2: rule__ClassDeclaration__Group_2_2_1__0
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2_1__0_in_rule__ClassDeclaration__Group_2_2__1__Impl9470);
+ rule__ClassDeclaration__Group_2_2_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getGroup_2_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2__1__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4429:1: rule__ClassDeclaration__Group_2_2__2 : rule__ClassDeclaration__Group_2_2__2__Impl ;
+ public final void rule__ClassDeclaration__Group_2_2__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4433:1: ( rule__ClassDeclaration__Group_2_2__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4434:2: rule__ClassDeclaration__Group_2_2__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2__2__Impl_in_rule__ClassDeclaration__Group_2_2__29501);
+ rule__ClassDeclaration__Group_2_2__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2__2"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4440:1: rule__ClassDeclaration__Group_2_2__2__Impl : ( ( rule__ClassDeclaration__BodyAssignment_2_2_2 ) ) ;
+ public final void rule__ClassDeclaration__Group_2_2__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4444:1: ( ( ( rule__ClassDeclaration__BodyAssignment_2_2_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4445:1: ( ( rule__ClassDeclaration__BodyAssignment_2_2_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4445:1: ( ( rule__ClassDeclaration__BodyAssignment_2_2_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4446:1: ( rule__ClassDeclaration__BodyAssignment_2_2_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_2_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4447:1: ( rule__ClassDeclaration__BodyAssignment_2_2_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4447:2: rule__ClassDeclaration__BodyAssignment_2_2_2
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__BodyAssignment_2_2_2_in_rule__ClassDeclaration__Group_2_2__2__Impl9528);
+ rule__ClassDeclaration__BodyAssignment_2_2_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_2_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2__2__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4463:1: rule__ClassDeclaration__Group_2_2_1__0 : rule__ClassDeclaration__Group_2_2_1__0__Impl rule__ClassDeclaration__Group_2_2_1__1 ;
+ public final void rule__ClassDeclaration__Group_2_2_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4467:1: ( rule__ClassDeclaration__Group_2_2_1__0__Impl rule__ClassDeclaration__Group_2_2_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4468:2: rule__ClassDeclaration__Group_2_2_1__0__Impl rule__ClassDeclaration__Group_2_2_1__1
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2_1__0__Impl_in_rule__ClassDeclaration__Group_2_2_1__09564);
+ rule__ClassDeclaration__Group_2_2_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2_1__1_in_rule__ClassDeclaration__Group_2_2_1__09567);
+ rule__ClassDeclaration__Group_2_2_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2_1__0"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4475:1: rule__ClassDeclaration__Group_2_2_1__0__Impl : ( RULE_EXTENDS ) ;
+ public final void rule__ClassDeclaration__Group_2_2_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4479:1: ( ( RULE_EXTENDS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4480:1: ( RULE_EXTENDS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4480:1: ( RULE_EXTENDS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4481:1: RULE_EXTENDS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0());
+ }
+ match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_rule__ClassDeclaration__Group_2_2_1__0__Impl9594); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2_1__0__Impl"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4492:1: rule__ClassDeclaration__Group_2_2_1__1 : rule__ClassDeclaration__Group_2_2_1__1__Impl ;
+ public final void rule__ClassDeclaration__Group_2_2_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4496:1: ( rule__ClassDeclaration__Group_2_2_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4497:2: rule__ClassDeclaration__Group_2_2_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__Group_2_2_1__1__Impl_in_rule__ClassDeclaration__Group_2_2_1__19623);
+ rule__ClassDeclaration__Group_2_2_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2_1__1"
+
+
+ // $ANTLR start "rule__ClassDeclaration__Group_2_2_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4503:1: rule__ClassDeclaration__Group_2_2_1__1__Impl : ( ( rule__ClassDeclaration__ExtendAssignment_2_2_1_1 ) ) ;
+ public final void rule__ClassDeclaration__Group_2_2_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4507:1: ( ( ( rule__ClassDeclaration__ExtendAssignment_2_2_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4508:1: ( ( rule__ClassDeclaration__ExtendAssignment_2_2_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4508:1: ( ( rule__ClassDeclaration__ExtendAssignment_2_2_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4509:1: ( rule__ClassDeclaration__ExtendAssignment_2_2_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_2_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4510:1: ( rule__ClassDeclaration__ExtendAssignment_2_2_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4510:2: rule__ClassDeclaration__ExtendAssignment_2_2_1_1
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__ExtendAssignment_2_2_1_1_in_rule__ClassDeclaration__Group_2_2_1__1__Impl9650);
+ rule__ClassDeclaration__ExtendAssignment_2_2_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_2_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__Group_2_2_1__1__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4524:1: rule__AssignedClassDeclaration__Group__0 : rule__AssignedClassDeclaration__Group__0__Impl rule__AssignedClassDeclaration__Group__1 ;
+ public final void rule__AssignedClassDeclaration__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4528:1: ( rule__AssignedClassDeclaration__Group__0__Impl rule__AssignedClassDeclaration__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4529:2: rule__AssignedClassDeclaration__Group__0__Impl rule__AssignedClassDeclaration__Group__1
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group__0__Impl_in_rule__AssignedClassDeclaration__Group__09684);
+ rule__AssignedClassDeclaration__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group__1_in_rule__AssignedClassDeclaration__Group__09687);
+ rule__AssignedClassDeclaration__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group__0"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4536:1: rule__AssignedClassDeclaration__Group__0__Impl : ( () ) ;
+ public final void rule__AssignedClassDeclaration__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4540:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4541:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4541:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4542:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4543:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4545:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group__0__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4555:1: rule__AssignedClassDeclaration__Group__1 : rule__AssignedClassDeclaration__Group__1__Impl rule__AssignedClassDeclaration__Group__2 ;
+ public final void rule__AssignedClassDeclaration__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4559:1: ( rule__AssignedClassDeclaration__Group__1__Impl rule__AssignedClassDeclaration__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4560:2: rule__AssignedClassDeclaration__Group__1__Impl rule__AssignedClassDeclaration__Group__2
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group__1__Impl_in_rule__AssignedClassDeclaration__Group__19745);
+ rule__AssignedClassDeclaration__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group__2_in_rule__AssignedClassDeclaration__Group__19748);
+ rule__AssignedClassDeclaration__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group__1"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4567:1: rule__AssignedClassDeclaration__Group__1__Impl : ( RULE_CLASS ) ;
+ public final void rule__AssignedClassDeclaration__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4571:1: ( ( RULE_CLASS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4572:1: ( RULE_CLASS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4572:1: ( RULE_CLASS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4573:1: RULE_CLASS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+ }
+ match(input,RULE_CLASS,FOLLOW_RULE_CLASS_in_rule__AssignedClassDeclaration__Group__1__Impl9775); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group__1__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4584:1: rule__AssignedClassDeclaration__Group__2 : rule__AssignedClassDeclaration__Group__2__Impl ;
+ public final void rule__AssignedClassDeclaration__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4588:1: ( rule__AssignedClassDeclaration__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4589:2: rule__AssignedClassDeclaration__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group__2__Impl_in_rule__AssignedClassDeclaration__Group__29804);
+ rule__AssignedClassDeclaration__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group__2"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4595:1: rule__AssignedClassDeclaration__Group__2__Impl : ( ( rule__AssignedClassDeclaration__Alternatives_2 )? ) ;
+ public final void rule__AssignedClassDeclaration__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4599:1: ( ( ( rule__AssignedClassDeclaration__Alternatives_2 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4600:1: ( ( rule__AssignedClassDeclaration__Alternatives_2 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4600:1: ( ( rule__AssignedClassDeclaration__Alternatives_2 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4601:1: ( rule__AssignedClassDeclaration__Alternatives_2 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getAlternatives_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4602:1: ( rule__AssignedClassDeclaration__Alternatives_2 )?
+ int alt54=2;
+ int LA54_0 = input.LA(1);
+
+ if ( (LA54_0==RULE_EXTENDS||LA54_0==RULE_IDENTIFIER) ) {
+ alt54=1;
+ }
+ switch (alt54) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4602:2: rule__AssignedClassDeclaration__Alternatives_2
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Alternatives_2_in_rule__AssignedClassDeclaration__Group__2__Impl9831);
+ rule__AssignedClassDeclaration__Alternatives_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getAlternatives_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group__2__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4618:1: rule__AssignedClassDeclaration__Group_2_0__0 : rule__AssignedClassDeclaration__Group_2_0__0__Impl rule__AssignedClassDeclaration__Group_2_0__1 ;
+ public final void rule__AssignedClassDeclaration__Group_2_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4622:1: ( rule__AssignedClassDeclaration__Group_2_0__0__Impl rule__AssignedClassDeclaration__Group_2_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4623:2: rule__AssignedClassDeclaration__Group_2_0__0__Impl rule__AssignedClassDeclaration__Group_2_0__1
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_0__0__Impl_in_rule__AssignedClassDeclaration__Group_2_0__09868);
+ rule__AssignedClassDeclaration__Group_2_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_0__1_in_rule__AssignedClassDeclaration__Group_2_0__09871);
+ rule__AssignedClassDeclaration__Group_2_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_0__0"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4630:1: rule__AssignedClassDeclaration__Group_2_0__0__Impl : ( RULE_EXTENDS ) ;
+ public final void rule__AssignedClassDeclaration__Group_2_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4634:1: ( ( RULE_EXTENDS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4635:1: ( RULE_EXTENDS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4635:1: ( RULE_EXTENDS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4636:1: RULE_EXTENDS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0());
+ }
+ match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_rule__AssignedClassDeclaration__Group_2_0__0__Impl9898); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_0__0__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4647:1: rule__AssignedClassDeclaration__Group_2_0__1 : rule__AssignedClassDeclaration__Group_2_0__1__Impl rule__AssignedClassDeclaration__Group_2_0__2 ;
+ public final void rule__AssignedClassDeclaration__Group_2_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4651:1: ( rule__AssignedClassDeclaration__Group_2_0__1__Impl rule__AssignedClassDeclaration__Group_2_0__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4652:2: rule__AssignedClassDeclaration__Group_2_0__1__Impl rule__AssignedClassDeclaration__Group_2_0__2
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_0__1__Impl_in_rule__AssignedClassDeclaration__Group_2_0__19927);
+ rule__AssignedClassDeclaration__Group_2_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_0__2_in_rule__AssignedClassDeclaration__Group_2_0__19930);
+ rule__AssignedClassDeclaration__Group_2_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_0__1"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4659:1: rule__AssignedClassDeclaration__Group_2_0__1__Impl : ( ( rule__AssignedClassDeclaration__ExtendAssignment_2_0_1 ) ) ;
+ public final void rule__AssignedClassDeclaration__Group_2_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4663:1: ( ( ( rule__AssignedClassDeclaration__ExtendAssignment_2_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4664:1: ( ( rule__AssignedClassDeclaration__ExtendAssignment_2_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4664:1: ( ( rule__AssignedClassDeclaration__ExtendAssignment_2_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4665:1: ( rule__AssignedClassDeclaration__ExtendAssignment_2_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4666:1: ( rule__AssignedClassDeclaration__ExtendAssignment_2_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4666:2: rule__AssignedClassDeclaration__ExtendAssignment_2_0_1
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__ExtendAssignment_2_0_1_in_rule__AssignedClassDeclaration__Group_2_0__1__Impl9957);
+ rule__AssignedClassDeclaration__ExtendAssignment_2_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_0__1__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_0__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4676:1: rule__AssignedClassDeclaration__Group_2_0__2 : rule__AssignedClassDeclaration__Group_2_0__2__Impl ;
+ public final void rule__AssignedClassDeclaration__Group_2_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4680:1: ( rule__AssignedClassDeclaration__Group_2_0__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4681:2: rule__AssignedClassDeclaration__Group_2_0__2__Impl
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_0__2__Impl_in_rule__AssignedClassDeclaration__Group_2_0__29987);
+ rule__AssignedClassDeclaration__Group_2_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_0__2"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_0__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4687:1: rule__AssignedClassDeclaration__Group_2_0__2__Impl : ( ( rule__AssignedClassDeclaration__BodyAssignment_2_0_2 ) ) ;
+ public final void rule__AssignedClassDeclaration__Group_2_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4691:1: ( ( ( rule__AssignedClassDeclaration__BodyAssignment_2_0_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4692:1: ( ( rule__AssignedClassDeclaration__BodyAssignment_2_0_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4692:1: ( ( rule__AssignedClassDeclaration__BodyAssignment_2_0_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4693:1: ( rule__AssignedClassDeclaration__BodyAssignment_2_0_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_0_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4694:1: ( rule__AssignedClassDeclaration__BodyAssignment_2_0_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4694:2: rule__AssignedClassDeclaration__BodyAssignment_2_0_2
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__BodyAssignment_2_0_2_in_rule__AssignedClassDeclaration__Group_2_0__2__Impl10014);
+ rule__AssignedClassDeclaration__BodyAssignment_2_0_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_0__2__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4710:1: rule__AssignedClassDeclaration__Group_2_1__0 : rule__AssignedClassDeclaration__Group_2_1__0__Impl rule__AssignedClassDeclaration__Group_2_1__1 ;
+ public final void rule__AssignedClassDeclaration__Group_2_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4714:1: ( rule__AssignedClassDeclaration__Group_2_1__0__Impl rule__AssignedClassDeclaration__Group_2_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4715:2: rule__AssignedClassDeclaration__Group_2_1__0__Impl rule__AssignedClassDeclaration__Group_2_1__1
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1__0__Impl_in_rule__AssignedClassDeclaration__Group_2_1__010050);
+ rule__AssignedClassDeclaration__Group_2_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1__1_in_rule__AssignedClassDeclaration__Group_2_1__010053);
+ rule__AssignedClassDeclaration__Group_2_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1__0"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4722:1: rule__AssignedClassDeclaration__Group_2_1__0__Impl : ( ( rule__AssignedClassDeclaration__NameAssignment_2_1_0 ) ) ;
+ public final void rule__AssignedClassDeclaration__Group_2_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4726:1: ( ( ( rule__AssignedClassDeclaration__NameAssignment_2_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4727:1: ( ( rule__AssignedClassDeclaration__NameAssignment_2_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4727:1: ( ( rule__AssignedClassDeclaration__NameAssignment_2_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4728:1: ( rule__AssignedClassDeclaration__NameAssignment_2_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getNameAssignment_2_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4729:1: ( rule__AssignedClassDeclaration__NameAssignment_2_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4729:2: rule__AssignedClassDeclaration__NameAssignment_2_1_0
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__NameAssignment_2_1_0_in_rule__AssignedClassDeclaration__Group_2_1__0__Impl10080);
+ rule__AssignedClassDeclaration__NameAssignment_2_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getNameAssignment_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1__0__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4739:1: rule__AssignedClassDeclaration__Group_2_1__1 : rule__AssignedClassDeclaration__Group_2_1__1__Impl rule__AssignedClassDeclaration__Group_2_1__2 ;
+ public final void rule__AssignedClassDeclaration__Group_2_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4743:1: ( rule__AssignedClassDeclaration__Group_2_1__1__Impl rule__AssignedClassDeclaration__Group_2_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4744:2: rule__AssignedClassDeclaration__Group_2_1__1__Impl rule__AssignedClassDeclaration__Group_2_1__2
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1__1__Impl_in_rule__AssignedClassDeclaration__Group_2_1__110110);
+ rule__AssignedClassDeclaration__Group_2_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1__2_in_rule__AssignedClassDeclaration__Group_2_1__110113);
+ rule__AssignedClassDeclaration__Group_2_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1__1"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4751:1: rule__AssignedClassDeclaration__Group_2_1__1__Impl : ( ( rule__AssignedClassDeclaration__Group_2_1_1__0 )? ) ;
+ public final void rule__AssignedClassDeclaration__Group_2_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4755:1: ( ( ( rule__AssignedClassDeclaration__Group_2_1_1__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4756:1: ( ( rule__AssignedClassDeclaration__Group_2_1_1__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4756:1: ( ( rule__AssignedClassDeclaration__Group_2_1_1__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4757:1: ( rule__AssignedClassDeclaration__Group_2_1_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4758:1: ( rule__AssignedClassDeclaration__Group_2_1_1__0 )?
+ int alt55=2;
+ int LA55_0 = input.LA(1);
+
+ if ( (LA55_0==RULE_EXTENDS) ) {
+ alt55=1;
+ }
+ switch (alt55) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4758:2: rule__AssignedClassDeclaration__Group_2_1_1__0
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1_1__0_in_rule__AssignedClassDeclaration__Group_2_1__1__Impl10140);
+ rule__AssignedClassDeclaration__Group_2_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1__1__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4768:1: rule__AssignedClassDeclaration__Group_2_1__2 : rule__AssignedClassDeclaration__Group_2_1__2__Impl ;
+ public final void rule__AssignedClassDeclaration__Group_2_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4772:1: ( rule__AssignedClassDeclaration__Group_2_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4773:2: rule__AssignedClassDeclaration__Group_2_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1__2__Impl_in_rule__AssignedClassDeclaration__Group_2_1__210171);
+ rule__AssignedClassDeclaration__Group_2_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1__2"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4779:1: rule__AssignedClassDeclaration__Group_2_1__2__Impl : ( ( rule__AssignedClassDeclaration__BodyAssignment_2_1_2 ) ) ;
+ public final void rule__AssignedClassDeclaration__Group_2_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4783:1: ( ( ( rule__AssignedClassDeclaration__BodyAssignment_2_1_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4784:1: ( ( rule__AssignedClassDeclaration__BodyAssignment_2_1_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4784:1: ( ( rule__AssignedClassDeclaration__BodyAssignment_2_1_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4785:1: ( rule__AssignedClassDeclaration__BodyAssignment_2_1_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4786:1: ( rule__AssignedClassDeclaration__BodyAssignment_2_1_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4786:2: rule__AssignedClassDeclaration__BodyAssignment_2_1_2
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__BodyAssignment_2_1_2_in_rule__AssignedClassDeclaration__Group_2_1__2__Impl10198);
+ rule__AssignedClassDeclaration__BodyAssignment_2_1_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1__2__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4802:1: rule__AssignedClassDeclaration__Group_2_1_1__0 : rule__AssignedClassDeclaration__Group_2_1_1__0__Impl rule__AssignedClassDeclaration__Group_2_1_1__1 ;
+ public final void rule__AssignedClassDeclaration__Group_2_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4806:1: ( rule__AssignedClassDeclaration__Group_2_1_1__0__Impl rule__AssignedClassDeclaration__Group_2_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4807:2: rule__AssignedClassDeclaration__Group_2_1_1__0__Impl rule__AssignedClassDeclaration__Group_2_1_1__1
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1_1__0__Impl_in_rule__AssignedClassDeclaration__Group_2_1_1__010234);
+ rule__AssignedClassDeclaration__Group_2_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1_1__1_in_rule__AssignedClassDeclaration__Group_2_1_1__010237);
+ rule__AssignedClassDeclaration__Group_2_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1_1__0"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4814:1: rule__AssignedClassDeclaration__Group_2_1_1__0__Impl : ( RULE_EXTENDS ) ;
+ public final void rule__AssignedClassDeclaration__Group_2_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4818:1: ( ( RULE_EXTENDS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4819:1: ( RULE_EXTENDS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4819:1: ( RULE_EXTENDS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4820:1: RULE_EXTENDS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0());
+ }
+ match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_rule__AssignedClassDeclaration__Group_2_1_1__0__Impl10264); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4831:1: rule__AssignedClassDeclaration__Group_2_1_1__1 : rule__AssignedClassDeclaration__Group_2_1_1__1__Impl ;
+ public final void rule__AssignedClassDeclaration__Group_2_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4835:1: ( rule__AssignedClassDeclaration__Group_2_1_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4836:2: rule__AssignedClassDeclaration__Group_2_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__Group_2_1_1__1__Impl_in_rule__AssignedClassDeclaration__Group_2_1_1__110293);
+ rule__AssignedClassDeclaration__Group_2_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1_1__1"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__Group_2_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4842:1: rule__AssignedClassDeclaration__Group_2_1_1__1__Impl : ( ( rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1 ) ) ;
+ public final void rule__AssignedClassDeclaration__Group_2_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4846:1: ( ( ( rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4847:1: ( ( rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4847:1: ( ( rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4848:1: ( rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4849:1: ( rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4849:2: rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1_in_rule__AssignedClassDeclaration__Group_2_1_1__1__Impl10320);
+ rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__Group_2_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4863:1: rule__Postfix__Group__0 : rule__Postfix__Group__0__Impl rule__Postfix__Group__1 ;
+ public final void rule__Postfix__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4867:1: ( rule__Postfix__Group__0__Impl rule__Postfix__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4868:2: rule__Postfix__Group__0__Impl rule__Postfix__Group__1
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group__0__Impl_in_rule__Postfix__Group__010354);
+ rule__Postfix__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group__1_in_rule__Postfix__Group__010357);
+ rule__Postfix__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group__0"
+
+
+ // $ANTLR start "rule__Postfix__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4875:1: rule__Postfix__Group__0__Impl : ( ruleAssignment ) ;
+ public final void rule__Postfix__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4879:1: ( ( ruleAssignment ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4880:1: ( ruleAssignment )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4880:1: ( ruleAssignment )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4881:1: ruleAssignment
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleAssignment_in_rule__Postfix__Group__0__Impl10384);
+ ruleAssignment();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4892:1: rule__Postfix__Group__1 : rule__Postfix__Group__1__Impl ;
+ public final void rule__Postfix__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4896:1: ( rule__Postfix__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4897:2: rule__Postfix__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group__1__Impl_in_rule__Postfix__Group__110413);
+ rule__Postfix__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group__1"
+
+
+ // $ANTLR start "rule__Postfix__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4903:1: rule__Postfix__Group__1__Impl : ( ( rule__Postfix__Alternatives_1 )? ) ;
+ public final void rule__Postfix__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4907:1: ( ( ( rule__Postfix__Alternatives_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4908:1: ( ( rule__Postfix__Alternatives_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4908:1: ( ( rule__Postfix__Alternatives_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4909:1: ( rule__Postfix__Alternatives_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getAlternatives_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4910:1: ( rule__Postfix__Alternatives_1 )?
+ int alt56=2;
+ switch ( input.LA(1) ) {
+ case RULE_POST_IF:
+ {
+ int LA56_1 = input.LA(2);
+
+ if ( (synpred89_InternalCakefile()) ) {
+ alt56=1;
+ }
+ }
+ break;
+ case RULE_FOR:
+ {
+ int LA56_2 = input.LA(2);
+
+ if ( (synpred89_InternalCakefile()) ) {
+ alt56=1;
+ }
+ }
+ break;
+ case RULE_WHILE:
+ {
+ int LA56_3 = input.LA(2);
+
+ if ( (synpred89_InternalCakefile()) ) {
+ alt56=1;
+ }
+ }
+ break;
+ case RULE_UNTIL:
+ {
+ int LA56_4 = input.LA(2);
+
+ if ( (synpred89_InternalCakefile()) ) {
+ alt56=1;
+ }
+ }
+ break;
+ }
+
+ switch (alt56) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4910:2: rule__Postfix__Alternatives_1
+ {
+ pushFollow(FOLLOW_rule__Postfix__Alternatives_1_in_rule__Postfix__Group__1__Impl10440);
+ rule__Postfix__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4924:1: rule__Postfix__Group_1_0__0 : rule__Postfix__Group_1_0__0__Impl rule__Postfix__Group_1_0__1 ;
+ public final void rule__Postfix__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4928:1: ( rule__Postfix__Group_1_0__0__Impl rule__Postfix__Group_1_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4929:2: rule__Postfix__Group_1_0__0__Impl rule__Postfix__Group_1_0__1
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_0__0__Impl_in_rule__Postfix__Group_1_0__010475);
+ rule__Postfix__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_0__1_in_rule__Postfix__Group_1_0__010478);
+ rule__Postfix__Group_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_0__0"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4936:1: rule__Postfix__Group_1_0__0__Impl : ( ( RULE_POST_IF ) ) ;
+ public final void rule__Postfix__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4940:1: ( ( ( RULE_POST_IF ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4941:1: ( ( RULE_POST_IF ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4941:1: ( ( RULE_POST_IF ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4942:1: ( RULE_POST_IF )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4943:1: ( RULE_POST_IF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4943:3: RULE_POST_IF
+ {
+ match(input,RULE_POST_IF,FOLLOW_RULE_POST_IF_in_rule__Postfix__Group_1_0__0__Impl10506); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4953:1: rule__Postfix__Group_1_0__1 : rule__Postfix__Group_1_0__1__Impl rule__Postfix__Group_1_0__2 ;
+ public final void rule__Postfix__Group_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4957:1: ( rule__Postfix__Group_1_0__1__Impl rule__Postfix__Group_1_0__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4958:2: rule__Postfix__Group_1_0__1__Impl rule__Postfix__Group_1_0__2
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_0__1__Impl_in_rule__Postfix__Group_1_0__110536);
+ rule__Postfix__Group_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_0__2_in_rule__Postfix__Group_1_0__110539);
+ rule__Postfix__Group_1_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_0__1"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4965:1: rule__Postfix__Group_1_0__1__Impl : ( () ) ;
+ public final void rule__Postfix__Group_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4969:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4970:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4970:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4971:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4972:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4974:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_0__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4984:1: rule__Postfix__Group_1_0__2 : rule__Postfix__Group_1_0__2__Impl ;
+ public final void rule__Postfix__Group_1_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4988:1: ( rule__Postfix__Group_1_0__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4989:2: rule__Postfix__Group_1_0__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_0__2__Impl_in_rule__Postfix__Group_1_0__210597);
+ rule__Postfix__Group_1_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_0__2"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_0__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4995:1: rule__Postfix__Group_1_0__2__Impl : ( ( rule__Postfix__ConditionAssignment_1_0_2 ) ) ;
+ public final void rule__Postfix__Group_1_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4999:1: ( ( ( rule__Postfix__ConditionAssignment_1_0_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5000:1: ( ( rule__Postfix__ConditionAssignment_1_0_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5000:1: ( ( rule__Postfix__ConditionAssignment_1_0_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5001:1: ( rule__Postfix__ConditionAssignment_1_0_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getConditionAssignment_1_0_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5002:1: ( rule__Postfix__ConditionAssignment_1_0_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5002:2: rule__Postfix__ConditionAssignment_1_0_2
+ {
+ pushFollow(FOLLOW_rule__Postfix__ConditionAssignment_1_0_2_in_rule__Postfix__Group_1_0__2__Impl10624);
+ rule__Postfix__ConditionAssignment_1_0_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getConditionAssignment_1_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_0__2__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5018:1: rule__Postfix__Group_1_1__0 : rule__Postfix__Group_1_1__0__Impl rule__Postfix__Group_1_1__1 ;
+ public final void rule__Postfix__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5022:1: ( rule__Postfix__Group_1_1__0__Impl rule__Postfix__Group_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5023:2: rule__Postfix__Group_1_1__0__Impl rule__Postfix__Group_1_1__1
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_1__0__Impl_in_rule__Postfix__Group_1_1__010660);
+ rule__Postfix__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_1__1_in_rule__Postfix__Group_1_1__010663);
+ rule__Postfix__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_1__0"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5030:1: rule__Postfix__Group_1_1__0__Impl : ( ( RULE_FOR ) ) ;
+ public final void rule__Postfix__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5034:1: ( ( ( RULE_FOR ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5035:1: ( ( RULE_FOR ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5035:1: ( ( RULE_FOR ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5036:1: ( RULE_FOR )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5037:1: ( RULE_FOR )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5037:3: RULE_FOR
+ {
+ match(input,RULE_FOR,FOLLOW_RULE_FOR_in_rule__Postfix__Group_1_1__0__Impl10691); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5047:1: rule__Postfix__Group_1_1__1 : rule__Postfix__Group_1_1__1__Impl rule__Postfix__Group_1_1__2 ;
+ public final void rule__Postfix__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5051:1: ( rule__Postfix__Group_1_1__1__Impl rule__Postfix__Group_1_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5052:2: rule__Postfix__Group_1_1__1__Impl rule__Postfix__Group_1_1__2
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_1__1__Impl_in_rule__Postfix__Group_1_1__110721);
+ rule__Postfix__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_1__2_in_rule__Postfix__Group_1_1__110724);
+ rule__Postfix__Group_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_1__1"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5059:1: rule__Postfix__Group_1_1__1__Impl : ( () ) ;
+ public final void rule__Postfix__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5063:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5064:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5064:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5065:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getForDummyAction_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5066:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5068:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getForDummyAction_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5078:1: rule__Postfix__Group_1_1__2 : rule__Postfix__Group_1_1__2__Impl ;
+ public final void rule__Postfix__Group_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5082:1: ( rule__Postfix__Group_1_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5083:2: rule__Postfix__Group_1_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_1__2__Impl_in_rule__Postfix__Group_1_1__210782);
+ rule__Postfix__Group_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_1__2"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5089:1: rule__Postfix__Group_1_1__2__Impl : ( ( rule__Postfix__BodyAssignment_1_1_2 ) ) ;
+ public final void rule__Postfix__Group_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5093:1: ( ( ( rule__Postfix__BodyAssignment_1_1_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5094:1: ( ( rule__Postfix__BodyAssignment_1_1_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5094:1: ( ( rule__Postfix__BodyAssignment_1_1_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5095:1: ( rule__Postfix__BodyAssignment_1_1_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getBodyAssignment_1_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5096:1: ( rule__Postfix__BodyAssignment_1_1_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5096:2: rule__Postfix__BodyAssignment_1_1_2
+ {
+ pushFollow(FOLLOW_rule__Postfix__BodyAssignment_1_1_2_in_rule__Postfix__Group_1_1__2__Impl10809);
+ rule__Postfix__BodyAssignment_1_1_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getBodyAssignment_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5112:1: rule__Postfix__Group_1_2__0 : rule__Postfix__Group_1_2__0__Impl rule__Postfix__Group_1_2__1 ;
+ public final void rule__Postfix__Group_1_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5116:1: ( rule__Postfix__Group_1_2__0__Impl rule__Postfix__Group_1_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5117:2: rule__Postfix__Group_1_2__0__Impl rule__Postfix__Group_1_2__1
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2__0__Impl_in_rule__Postfix__Group_1_2__010845);
+ rule__Postfix__Group_1_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2__1_in_rule__Postfix__Group_1_2__010848);
+ rule__Postfix__Group_1_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2__0"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5124:1: rule__Postfix__Group_1_2__0__Impl : ( ( RULE_WHILE ) ) ;
+ public final void rule__Postfix__Group_1_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5128:1: ( ( ( RULE_WHILE ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5129:1: ( ( RULE_WHILE ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5129:1: ( ( RULE_WHILE ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5130:1: ( RULE_WHILE )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5131:1: ( RULE_WHILE )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5131:3: RULE_WHILE
+ {
+ match(input,RULE_WHILE,FOLLOW_RULE_WHILE_in_rule__Postfix__Group_1_2__0__Impl10876); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2__0__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5141:1: rule__Postfix__Group_1_2__1 : rule__Postfix__Group_1_2__1__Impl rule__Postfix__Group_1_2__2 ;
+ public final void rule__Postfix__Group_1_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5145:1: ( rule__Postfix__Group_1_2__1__Impl rule__Postfix__Group_1_2__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5146:2: rule__Postfix__Group_1_2__1__Impl rule__Postfix__Group_1_2__2
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2__1__Impl_in_rule__Postfix__Group_1_2__110906);
+ rule__Postfix__Group_1_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2__2_in_rule__Postfix__Group_1_2__110909);
+ rule__Postfix__Group_1_2__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2__1"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5153:1: rule__Postfix__Group_1_2__1__Impl : ( () ) ;
+ public final void rule__Postfix__Group_1_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5157:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5158:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5158:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5159:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5160:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5162:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2__1__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5172:1: rule__Postfix__Group_1_2__2 : rule__Postfix__Group_1_2__2__Impl rule__Postfix__Group_1_2__3 ;
+ public final void rule__Postfix__Group_1_2__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5176:1: ( rule__Postfix__Group_1_2__2__Impl rule__Postfix__Group_1_2__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5177:2: rule__Postfix__Group_1_2__2__Impl rule__Postfix__Group_1_2__3
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2__2__Impl_in_rule__Postfix__Group_1_2__210967);
+ rule__Postfix__Group_1_2__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2__3_in_rule__Postfix__Group_1_2__210970);
+ rule__Postfix__Group_1_2__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2__2"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5184:1: rule__Postfix__Group_1_2__2__Impl : ( ( rule__Postfix__BodyAssignment_1_2_2 ) ) ;
+ public final void rule__Postfix__Group_1_2__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5188:1: ( ( ( rule__Postfix__BodyAssignment_1_2_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5189:1: ( ( rule__Postfix__BodyAssignment_1_2_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5189:1: ( ( rule__Postfix__BodyAssignment_1_2_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5190:1: ( rule__Postfix__BodyAssignment_1_2_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getBodyAssignment_1_2_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5191:1: ( rule__Postfix__BodyAssignment_1_2_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5191:2: rule__Postfix__BodyAssignment_1_2_2
+ {
+ pushFollow(FOLLOW_rule__Postfix__BodyAssignment_1_2_2_in_rule__Postfix__Group_1_2__2__Impl10997);
+ rule__Postfix__BodyAssignment_1_2_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getBodyAssignment_1_2_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2__2__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5201:1: rule__Postfix__Group_1_2__3 : rule__Postfix__Group_1_2__3__Impl ;
+ public final void rule__Postfix__Group_1_2__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5205:1: ( rule__Postfix__Group_1_2__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5206:2: rule__Postfix__Group_1_2__3__Impl
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2__3__Impl_in_rule__Postfix__Group_1_2__311027);
+ rule__Postfix__Group_1_2__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2__3"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5212:1: rule__Postfix__Group_1_2__3__Impl : ( ( rule__Postfix__Group_1_2_3__0 )? ) ;
+ public final void rule__Postfix__Group_1_2__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5216:1: ( ( ( rule__Postfix__Group_1_2_3__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5217:1: ( ( rule__Postfix__Group_1_2_3__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5217:1: ( ( rule__Postfix__Group_1_2_3__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5218:1: ( rule__Postfix__Group_1_2_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getGroup_1_2_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5219:1: ( rule__Postfix__Group_1_2_3__0 )?
+ int alt57=2;
+ int LA57_0 = input.LA(1);
+
+ if ( (LA57_0==RULE_WHEN) ) {
+ int LA57_1 = input.LA(2);
+
+ if ( (synpred90_InternalCakefile()) ) {
+ alt57=1;
+ }
+ }
+ switch (alt57) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5219:2: rule__Postfix__Group_1_2_3__0
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2_3__0_in_rule__Postfix__Group_1_2__3__Impl11054);
+ rule__Postfix__Group_1_2_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getGroup_1_2_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2__3__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2_3__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5237:1: rule__Postfix__Group_1_2_3__0 : rule__Postfix__Group_1_2_3__0__Impl rule__Postfix__Group_1_2_3__1 ;
+ public final void rule__Postfix__Group_1_2_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5241:1: ( rule__Postfix__Group_1_2_3__0__Impl rule__Postfix__Group_1_2_3__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5242:2: rule__Postfix__Group_1_2_3__0__Impl rule__Postfix__Group_1_2_3__1
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2_3__0__Impl_in_rule__Postfix__Group_1_2_3__011093);
+ rule__Postfix__Group_1_2_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2_3__1_in_rule__Postfix__Group_1_2_3__011096);
+ rule__Postfix__Group_1_2_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2_3__0"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2_3__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5249:1: rule__Postfix__Group_1_2_3__0__Impl : ( ( RULE_WHEN ) ) ;
+ public final void rule__Postfix__Group_1_2_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5253:1: ( ( ( RULE_WHEN ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5254:1: ( ( RULE_WHEN ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5254:1: ( ( RULE_WHEN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5255:1: ( RULE_WHEN )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5256:1: ( RULE_WHEN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5256:3: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rule__Postfix__Group_1_2_3__0__Impl11124); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2_3__0__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2_3__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5266:1: rule__Postfix__Group_1_2_3__1 : rule__Postfix__Group_1_2_3__1__Impl ;
+ public final void rule__Postfix__Group_1_2_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5270:1: ( rule__Postfix__Group_1_2_3__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5271:2: rule__Postfix__Group_1_2_3__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2_3__1__Impl_in_rule__Postfix__Group_1_2_3__111154);
+ rule__Postfix__Group_1_2_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2_3__1"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_2_3__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5277:1: rule__Postfix__Group_1_2_3__1__Impl : ( ( rule__Postfix__WhenAssignment_1_2_3_1 ) ) ;
+ public final void rule__Postfix__Group_1_2_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5281:1: ( ( ( rule__Postfix__WhenAssignment_1_2_3_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5282:1: ( ( rule__Postfix__WhenAssignment_1_2_3_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5282:1: ( ( rule__Postfix__WhenAssignment_1_2_3_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5283:1: ( rule__Postfix__WhenAssignment_1_2_3_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getWhenAssignment_1_2_3_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5284:1: ( rule__Postfix__WhenAssignment_1_2_3_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5284:2: rule__Postfix__WhenAssignment_1_2_3_1
+ {
+ pushFollow(FOLLOW_rule__Postfix__WhenAssignment_1_2_3_1_in_rule__Postfix__Group_1_2_3__1__Impl11181);
+ rule__Postfix__WhenAssignment_1_2_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getWhenAssignment_1_2_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_2_3__1__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5298:1: rule__Postfix__Group_1_3__0 : rule__Postfix__Group_1_3__0__Impl rule__Postfix__Group_1_3__1 ;
+ public final void rule__Postfix__Group_1_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5302:1: ( rule__Postfix__Group_1_3__0__Impl rule__Postfix__Group_1_3__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5303:2: rule__Postfix__Group_1_3__0__Impl rule__Postfix__Group_1_3__1
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3__0__Impl_in_rule__Postfix__Group_1_3__011215);
+ rule__Postfix__Group_1_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3__1_in_rule__Postfix__Group_1_3__011218);
+ rule__Postfix__Group_1_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3__0"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5310:1: rule__Postfix__Group_1_3__0__Impl : ( ( RULE_UNTIL ) ) ;
+ public final void rule__Postfix__Group_1_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5314:1: ( ( ( RULE_UNTIL ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5315:1: ( ( RULE_UNTIL ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5315:1: ( ( RULE_UNTIL ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5316:1: ( RULE_UNTIL )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5317:1: ( RULE_UNTIL )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5317:3: RULE_UNTIL
+ {
+ match(input,RULE_UNTIL,FOLLOW_RULE_UNTIL_in_rule__Postfix__Group_1_3__0__Impl11246); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3__0__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5327:1: rule__Postfix__Group_1_3__1 : rule__Postfix__Group_1_3__1__Impl rule__Postfix__Group_1_3__2 ;
+ public final void rule__Postfix__Group_1_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5331:1: ( rule__Postfix__Group_1_3__1__Impl rule__Postfix__Group_1_3__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5332:2: rule__Postfix__Group_1_3__1__Impl rule__Postfix__Group_1_3__2
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3__1__Impl_in_rule__Postfix__Group_1_3__111276);
+ rule__Postfix__Group_1_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3__2_in_rule__Postfix__Group_1_3__111279);
+ rule__Postfix__Group_1_3__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3__1"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5339:1: rule__Postfix__Group_1_3__1__Impl : ( () ) ;
+ public final void rule__Postfix__Group_1_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5343:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5344:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5344:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5345:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5346:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5348:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3__1__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5358:1: rule__Postfix__Group_1_3__2 : rule__Postfix__Group_1_3__2__Impl rule__Postfix__Group_1_3__3 ;
+ public final void rule__Postfix__Group_1_3__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5362:1: ( rule__Postfix__Group_1_3__2__Impl rule__Postfix__Group_1_3__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5363:2: rule__Postfix__Group_1_3__2__Impl rule__Postfix__Group_1_3__3
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3__2__Impl_in_rule__Postfix__Group_1_3__211337);
+ rule__Postfix__Group_1_3__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3__3_in_rule__Postfix__Group_1_3__211340);
+ rule__Postfix__Group_1_3__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3__2"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5370:1: rule__Postfix__Group_1_3__2__Impl : ( ( rule__Postfix__BodyAssignment_1_3_2 ) ) ;
+ public final void rule__Postfix__Group_1_3__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5374:1: ( ( ( rule__Postfix__BodyAssignment_1_3_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5375:1: ( ( rule__Postfix__BodyAssignment_1_3_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5375:1: ( ( rule__Postfix__BodyAssignment_1_3_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5376:1: ( rule__Postfix__BodyAssignment_1_3_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getBodyAssignment_1_3_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5377:1: ( rule__Postfix__BodyAssignment_1_3_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5377:2: rule__Postfix__BodyAssignment_1_3_2
+ {
+ pushFollow(FOLLOW_rule__Postfix__BodyAssignment_1_3_2_in_rule__Postfix__Group_1_3__2__Impl11367);
+ rule__Postfix__BodyAssignment_1_3_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getBodyAssignment_1_3_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3__2__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5387:1: rule__Postfix__Group_1_3__3 : rule__Postfix__Group_1_3__3__Impl ;
+ public final void rule__Postfix__Group_1_3__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5391:1: ( rule__Postfix__Group_1_3__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5392:2: rule__Postfix__Group_1_3__3__Impl
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3__3__Impl_in_rule__Postfix__Group_1_3__311397);
+ rule__Postfix__Group_1_3__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3__3"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5398:1: rule__Postfix__Group_1_3__3__Impl : ( ( rule__Postfix__Group_1_3_3__0 )? ) ;
+ public final void rule__Postfix__Group_1_3__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5402:1: ( ( ( rule__Postfix__Group_1_3_3__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5403:1: ( ( rule__Postfix__Group_1_3_3__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5403:1: ( ( rule__Postfix__Group_1_3_3__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5404:1: ( rule__Postfix__Group_1_3_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getGroup_1_3_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5405:1: ( rule__Postfix__Group_1_3_3__0 )?
+ int alt58=2;
+ int LA58_0 = input.LA(1);
+
+ if ( (LA58_0==RULE_WHEN) ) {
+ int LA58_1 = input.LA(2);
+
+ if ( (synpred91_InternalCakefile()) ) {
+ alt58=1;
+ }
+ }
+ switch (alt58) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5405:2: rule__Postfix__Group_1_3_3__0
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3_3__0_in_rule__Postfix__Group_1_3__3__Impl11424);
+ rule__Postfix__Group_1_3_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getGroup_1_3_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3__3__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3_3__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5423:1: rule__Postfix__Group_1_3_3__0 : rule__Postfix__Group_1_3_3__0__Impl rule__Postfix__Group_1_3_3__1 ;
+ public final void rule__Postfix__Group_1_3_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5427:1: ( rule__Postfix__Group_1_3_3__0__Impl rule__Postfix__Group_1_3_3__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5428:2: rule__Postfix__Group_1_3_3__0__Impl rule__Postfix__Group_1_3_3__1
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3_3__0__Impl_in_rule__Postfix__Group_1_3_3__011463);
+ rule__Postfix__Group_1_3_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3_3__1_in_rule__Postfix__Group_1_3_3__011466);
+ rule__Postfix__Group_1_3_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3_3__0"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3_3__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5435:1: rule__Postfix__Group_1_3_3__0__Impl : ( ( RULE_WHEN ) ) ;
+ public final void rule__Postfix__Group_1_3_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5439:1: ( ( ( RULE_WHEN ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5440:1: ( ( RULE_WHEN ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5440:1: ( ( RULE_WHEN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5441:1: ( RULE_WHEN )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5442:1: ( RULE_WHEN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5442:3: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rule__Postfix__Group_1_3_3__0__Impl11494); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3_3__0__Impl"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3_3__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5452:1: rule__Postfix__Group_1_3_3__1 : rule__Postfix__Group_1_3_3__1__Impl ;
+ public final void rule__Postfix__Group_1_3_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5456:1: ( rule__Postfix__Group_1_3_3__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5457:2: rule__Postfix__Group_1_3_3__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3_3__1__Impl_in_rule__Postfix__Group_1_3_3__111524);
+ rule__Postfix__Group_1_3_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3_3__1"
+
+
+ // $ANTLR start "rule__Postfix__Group_1_3_3__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5463:1: rule__Postfix__Group_1_3_3__1__Impl : ( ( rule__Postfix__WhenAssignment_1_3_3_1 ) ) ;
+ public final void rule__Postfix__Group_1_3_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5467:1: ( ( ( rule__Postfix__WhenAssignment_1_3_3_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5468:1: ( ( rule__Postfix__WhenAssignment_1_3_3_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5468:1: ( ( rule__Postfix__WhenAssignment_1_3_3_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5469:1: ( rule__Postfix__WhenAssignment_1_3_3_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getWhenAssignment_1_3_3_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5470:1: ( rule__Postfix__WhenAssignment_1_3_3_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5470:2: rule__Postfix__WhenAssignment_1_3_3_1
+ {
+ pushFollow(FOLLOW_rule__Postfix__WhenAssignment_1_3_3_1_in_rule__Postfix__Group_1_3_3__1__Impl11551);
+ rule__Postfix__WhenAssignment_1_3_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getWhenAssignment_1_3_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__Group_1_3_3__1__Impl"
+
+
+ // $ANTLR start "rule__ForBody__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5484:1: rule__ForBody__Group__0 : rule__ForBody__Group__0__Impl rule__ForBody__Group__1 ;
+ public final void rule__ForBody__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5488:1: ( rule__ForBody__Group__0__Impl rule__ForBody__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5489:2: rule__ForBody__Group__0__Impl rule__ForBody__Group__1
+ {
+ pushFollow(FOLLOW_rule__ForBody__Group__0__Impl_in_rule__ForBody__Group__011585);
+ rule__ForBody__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForBody__Group__1_in_rule__ForBody__Group__011588);
+ rule__ForBody__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group__0"
+
+
+ // $ANTLR start "rule__ForBody__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5496:1: rule__ForBody__Group__0__Impl : ( ( RULE_OWN )? ) ;
+ public final void rule__ForBody__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5500:1: ( ( ( RULE_OWN )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5501:1: ( ( RULE_OWN )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5501:1: ( ( RULE_OWN )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5502:1: ( RULE_OWN )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getOWNTerminalRuleCall_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5503:1: ( RULE_OWN )?
+ int alt59=2;
+ int LA59_0 = input.LA(1);
+
+ if ( (LA59_0==RULE_OWN) ) {
+ alt59=1;
+ }
+ switch (alt59) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5503:3: RULE_OWN
+ {
+ match(input,RULE_OWN,FOLLOW_RULE_OWN_in_rule__ForBody__Group__0__Impl11616); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getOWNTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ForBody__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5513:1: rule__ForBody__Group__1 : rule__ForBody__Group__1__Impl rule__ForBody__Group__2 ;
+ public final void rule__ForBody__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5517:1: ( rule__ForBody__Group__1__Impl rule__ForBody__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5518:2: rule__ForBody__Group__1__Impl rule__ForBody__Group__2
+ {
+ pushFollow(FOLLOW_rule__ForBody__Group__1__Impl_in_rule__ForBody__Group__111647);
+ rule__ForBody__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForBody__Group__2_in_rule__ForBody__Group__111650);
+ rule__ForBody__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group__1"
+
+
+ // $ANTLR start "rule__ForBody__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5525:1: rule__ForBody__Group__1__Impl : ( ( rule__ForBody__IndexesAssignment_1 ) ) ;
+ public final void rule__ForBody__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5529:1: ( ( ( rule__ForBody__IndexesAssignment_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5530:1: ( ( rule__ForBody__IndexesAssignment_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5530:1: ( ( rule__ForBody__IndexesAssignment_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5531:1: ( rule__ForBody__IndexesAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getIndexesAssignment_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5532:1: ( rule__ForBody__IndexesAssignment_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5532:2: rule__ForBody__IndexesAssignment_1
+ {
+ pushFollow(FOLLOW_rule__ForBody__IndexesAssignment_1_in_rule__ForBody__Group__1__Impl11677);
+ rule__ForBody__IndexesAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getIndexesAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ForBody__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5542:1: rule__ForBody__Group__2 : rule__ForBody__Group__2__Impl rule__ForBody__Group__3 ;
+ public final void rule__ForBody__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5546:1: ( rule__ForBody__Group__2__Impl rule__ForBody__Group__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5547:2: rule__ForBody__Group__2__Impl rule__ForBody__Group__3
+ {
+ pushFollow(FOLLOW_rule__ForBody__Group__2__Impl_in_rule__ForBody__Group__211707);
+ rule__ForBody__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForBody__Group__3_in_rule__ForBody__Group__211710);
+ rule__ForBody__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group__2"
+
+
+ // $ANTLR start "rule__ForBody__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5554:1: rule__ForBody__Group__2__Impl : ( ( rule__ForBody__Group_2__0 )* ) ;
+ public final void rule__ForBody__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5558:1: ( ( ( rule__ForBody__Group_2__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5559:1: ( ( rule__ForBody__Group_2__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5559:1: ( ( rule__ForBody__Group_2__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5560:1: ( rule__ForBody__Group_2__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getGroup_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5561:1: ( rule__ForBody__Group_2__0 )*
+ loop60:
+ do {
+ int alt60=2;
+ int LA60_0 = input.LA(1);
+
+ if ( (LA60_0==RULE_COMMA) ) {
+ alt60=1;
+ }
+
+
+ switch (alt60) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5561:2: rule__ForBody__Group_2__0
+ {
+ pushFollow(FOLLOW_rule__ForBody__Group_2__0_in_rule__ForBody__Group__2__Impl11737);
+ rule__ForBody__Group_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop60;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getGroup_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group__2__Impl"
+
+
+ // $ANTLR start "rule__ForBody__Group__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5571:1: rule__ForBody__Group__3 : rule__ForBody__Group__3__Impl ;
+ public final void rule__ForBody__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5575:1: ( rule__ForBody__Group__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5576:2: rule__ForBody__Group__3__Impl
+ {
+ pushFollow(FOLLOW_rule__ForBody__Group__3__Impl_in_rule__ForBody__Group__311768);
+ rule__ForBody__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group__3"
+
+
+ // $ANTLR start "rule__ForBody__Group__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5582:1: rule__ForBody__Group__3__Impl : ( ( rule__ForBody__SourceAssignment_3 ) ) ;
+ public final void rule__ForBody__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5586:1: ( ( ( rule__ForBody__SourceAssignment_3 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5587:1: ( ( rule__ForBody__SourceAssignment_3 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5587:1: ( ( rule__ForBody__SourceAssignment_3 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5588:1: ( rule__ForBody__SourceAssignment_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getSourceAssignment_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5589:1: ( rule__ForBody__SourceAssignment_3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5589:2: rule__ForBody__SourceAssignment_3
+ {
+ pushFollow(FOLLOW_rule__ForBody__SourceAssignment_3_in_rule__ForBody__Group__3__Impl11795);
+ rule__ForBody__SourceAssignment_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getSourceAssignment_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group__3__Impl"
+
+
+ // $ANTLR start "rule__ForBody__Group_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5607:1: rule__ForBody__Group_2__0 : rule__ForBody__Group_2__0__Impl rule__ForBody__Group_2__1 ;
+ public final void rule__ForBody__Group_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5611:1: ( rule__ForBody__Group_2__0__Impl rule__ForBody__Group_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5612:2: rule__ForBody__Group_2__0__Impl rule__ForBody__Group_2__1
+ {
+ pushFollow(FOLLOW_rule__ForBody__Group_2__0__Impl_in_rule__ForBody__Group_2__011833);
+ rule__ForBody__Group_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForBody__Group_2__1_in_rule__ForBody__Group_2__011836);
+ rule__ForBody__Group_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group_2__0"
+
+
+ // $ANTLR start "rule__ForBody__Group_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5619:1: rule__ForBody__Group_2__0__Impl : ( RULE_COMMA ) ;
+ public final void rule__ForBody__Group_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5623:1: ( ( RULE_COMMA ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5624:1: ( RULE_COMMA )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5624:1: ( RULE_COMMA )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5625:1: RULE_COMMA
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0());
+ }
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__ForBody__Group_2__0__Impl11863); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group_2__0__Impl"
+
+
+ // $ANTLR start "rule__ForBody__Group_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5636:1: rule__ForBody__Group_2__1 : rule__ForBody__Group_2__1__Impl ;
+ public final void rule__ForBody__Group_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5640:1: ( rule__ForBody__Group_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5641:2: rule__ForBody__Group_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ForBody__Group_2__1__Impl_in_rule__ForBody__Group_2__111892);
+ rule__ForBody__Group_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group_2__1"
+
+
+ // $ANTLR start "rule__ForBody__Group_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5647:1: rule__ForBody__Group_2__1__Impl : ( ( rule__ForBody__IndexesAssignment_2_1 ) ) ;
+ public final void rule__ForBody__Group_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5651:1: ( ( ( rule__ForBody__IndexesAssignment_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5652:1: ( ( rule__ForBody__IndexesAssignment_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5652:1: ( ( rule__ForBody__IndexesAssignment_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5653:1: ( rule__ForBody__IndexesAssignment_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getIndexesAssignment_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5654:1: ( rule__ForBody__IndexesAssignment_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5654:2: rule__ForBody__IndexesAssignment_2_1
+ {
+ pushFollow(FOLLOW_rule__ForBody__IndexesAssignment_2_1_in_rule__ForBody__Group_2__1__Impl11919);
+ rule__ForBody__IndexesAssignment_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getIndexesAssignment_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__Group_2__1__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5668:1: rule__ForSource__Group__0 : rule__ForSource__Group__0__Impl rule__ForSource__Group__1 ;
+ public final void rule__ForSource__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5672:1: ( rule__ForSource__Group__0__Impl rule__ForSource__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5673:2: rule__ForSource__Group__0__Impl rule__ForSource__Group__1
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group__0__Impl_in_rule__ForSource__Group__011953);
+ rule__ForSource__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group__1_in_rule__ForSource__Group__011956);
+ rule__ForSource__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group__0"
+
+
+ // $ANTLR start "rule__ForSource__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5680:1: rule__ForSource__Group__0__Impl : ( () ) ;
+ public final void rule__ForSource__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5684:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5685:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5685:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5686:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getForSourceAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5687:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5689:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getForSourceAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5699:1: rule__ForSource__Group__1 : rule__ForSource__Group__1__Impl ;
+ public final void rule__ForSource__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5703:1: ( rule__ForSource__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5704:2: rule__ForSource__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group__1__Impl_in_rule__ForSource__Group__112014);
+ rule__ForSource__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group__1"
+
+
+ // $ANTLR start "rule__ForSource__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5710:1: rule__ForSource__Group__1__Impl : ( ( rule__ForSource__Alternatives_1 ) ) ;
+ public final void rule__ForSource__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5714:1: ( ( ( rule__ForSource__Alternatives_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5715:1: ( ( rule__ForSource__Alternatives_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5715:1: ( ( rule__ForSource__Alternatives_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5716:1: ( rule__ForSource__Alternatives_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getAlternatives_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5717:1: ( rule__ForSource__Alternatives_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5717:2: rule__ForSource__Alternatives_1
+ {
+ pushFollow(FOLLOW_rule__ForSource__Alternatives_1_in_rule__ForSource__Group__1__Impl12041);
+ rule__ForSource__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5731:1: rule__ForSource__Group_1_0__0 : rule__ForSource__Group_1_0__0__Impl rule__ForSource__Group_1_0__1 ;
+ public final void rule__ForSource__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5735:1: ( rule__ForSource__Group_1_0__0__Impl rule__ForSource__Group_1_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5736:2: rule__ForSource__Group_1_0__0__Impl rule__ForSource__Group_1_0__1
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0__0__Impl_in_rule__ForSource__Group_1_0__012075);
+ rule__ForSource__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0__1_in_rule__ForSource__Group_1_0__012078);
+ rule__ForSource__Group_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0__0"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5743:1: rule__ForSource__Group_1_0__0__Impl : ( ( RULE_FOROF ) ) ;
+ public final void rule__ForSource__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5747:1: ( ( ( RULE_FOROF ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5748:1: ( ( RULE_FOROF ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5748:1: ( ( RULE_FOROF ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5749:1: ( RULE_FOROF )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5750:1: ( RULE_FOROF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5750:3: RULE_FOROF
+ {
+ match(input,RULE_FOROF,FOLLOW_RULE_FOROF_in_rule__ForSource__Group_1_0__0__Impl12106); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5760:1: rule__ForSource__Group_1_0__1 : rule__ForSource__Group_1_0__1__Impl rule__ForSource__Group_1_0__2 ;
+ public final void rule__ForSource__Group_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5764:1: ( rule__ForSource__Group_1_0__1__Impl rule__ForSource__Group_1_0__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5765:2: rule__ForSource__Group_1_0__1__Impl rule__ForSource__Group_1_0__2
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0__1__Impl_in_rule__ForSource__Group_1_0__112136);
+ rule__ForSource__Group_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0__2_in_rule__ForSource__Group_1_0__112139);
+ rule__ForSource__Group_1_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0__1"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5772:1: rule__ForSource__Group_1_0__1__Impl : ( ( rule__ForSource__SourceAssignment_1_0_1 ) ) ;
+ public final void rule__ForSource__Group_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5776:1: ( ( ( rule__ForSource__SourceAssignment_1_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5777:1: ( ( rule__ForSource__SourceAssignment_1_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5777:1: ( ( rule__ForSource__SourceAssignment_1_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5778:1: ( rule__ForSource__SourceAssignment_1_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getSourceAssignment_1_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5779:1: ( rule__ForSource__SourceAssignment_1_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5779:2: rule__ForSource__SourceAssignment_1_0_1
+ {
+ pushFollow(FOLLOW_rule__ForSource__SourceAssignment_1_0_1_in_rule__ForSource__Group_1_0__1__Impl12166);
+ rule__ForSource__SourceAssignment_1_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getSourceAssignment_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5789:1: rule__ForSource__Group_1_0__2 : rule__ForSource__Group_1_0__2__Impl ;
+ public final void rule__ForSource__Group_1_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5793:1: ( rule__ForSource__Group_1_0__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5794:2: rule__ForSource__Group_1_0__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0__2__Impl_in_rule__ForSource__Group_1_0__212196);
+ rule__ForSource__Group_1_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0__2"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5800:1: rule__ForSource__Group_1_0__2__Impl : ( ( rule__ForSource__Group_1_0_2__0 )? ) ;
+ public final void rule__ForSource__Group_1_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5804:1: ( ( ( rule__ForSource__Group_1_0_2__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5805:1: ( ( rule__ForSource__Group_1_0_2__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5805:1: ( ( rule__ForSource__Group_1_0_2__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5806:1: ( rule__ForSource__Group_1_0_2__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getGroup_1_0_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5807:1: ( rule__ForSource__Group_1_0_2__0 )?
+ int alt61=2;
+ int LA61_0 = input.LA(1);
+
+ if ( (LA61_0==RULE_WHEN) ) {
+ int LA61_1 = input.LA(2);
+
+ if ( (synpred94_InternalCakefile()) ) {
+ alt61=1;
+ }
+ }
+ switch (alt61) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5807:2: rule__ForSource__Group_1_0_2__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0_2__0_in_rule__ForSource__Group_1_0__2__Impl12223);
+ rule__ForSource__Group_1_0_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getGroup_1_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0__2__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5823:1: rule__ForSource__Group_1_0_2__0 : rule__ForSource__Group_1_0_2__0__Impl rule__ForSource__Group_1_0_2__1 ;
+ public final void rule__ForSource__Group_1_0_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5827:1: ( rule__ForSource__Group_1_0_2__0__Impl rule__ForSource__Group_1_0_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5828:2: rule__ForSource__Group_1_0_2__0__Impl rule__ForSource__Group_1_0_2__1
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0_2__0__Impl_in_rule__ForSource__Group_1_0_2__012260);
+ rule__ForSource__Group_1_0_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0_2__1_in_rule__ForSource__Group_1_0_2__012263);
+ rule__ForSource__Group_1_0_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0_2__0"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5835:1: rule__ForSource__Group_1_0_2__0__Impl : ( ( RULE_WHEN ) ) ;
+ public final void rule__ForSource__Group_1_0_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5839:1: ( ( ( RULE_WHEN ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5840:1: ( ( RULE_WHEN ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5840:1: ( ( RULE_WHEN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5841:1: ( RULE_WHEN )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5842:1: ( RULE_WHEN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5842:3: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rule__ForSource__Group_1_0_2__0__Impl12291); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0_2__0__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5852:1: rule__ForSource__Group_1_0_2__1 : rule__ForSource__Group_1_0_2__1__Impl ;
+ public final void rule__ForSource__Group_1_0_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5856:1: ( rule__ForSource__Group_1_0_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5857:2: rule__ForSource__Group_1_0_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0_2__1__Impl_in_rule__ForSource__Group_1_0_2__112321);
+ rule__ForSource__Group_1_0_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0_2__1"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_0_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5863:1: rule__ForSource__Group_1_0_2__1__Impl : ( ( rule__ForSource__WhenAssignment_1_0_2_1 ) ) ;
+ public final void rule__ForSource__Group_1_0_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5867:1: ( ( ( rule__ForSource__WhenAssignment_1_0_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5868:1: ( ( rule__ForSource__WhenAssignment_1_0_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5868:1: ( ( rule__ForSource__WhenAssignment_1_0_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5869:1: ( rule__ForSource__WhenAssignment_1_0_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getWhenAssignment_1_0_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5870:1: ( rule__ForSource__WhenAssignment_1_0_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5870:2: rule__ForSource__WhenAssignment_1_0_2_1
+ {
+ pushFollow(FOLLOW_rule__ForSource__WhenAssignment_1_0_2_1_in_rule__ForSource__Group_1_0_2__1__Impl12348);
+ rule__ForSource__WhenAssignment_1_0_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getWhenAssignment_1_0_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_0_2__1__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5884:1: rule__ForSource__Group_1_1__0 : rule__ForSource__Group_1_1__0__Impl rule__ForSource__Group_1_1__1 ;
+ public final void rule__ForSource__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5888:1: ( rule__ForSource__Group_1_1__0__Impl rule__ForSource__Group_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5889:2: rule__ForSource__Group_1_1__0__Impl rule__ForSource__Group_1_1__1
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1__0__Impl_in_rule__ForSource__Group_1_1__012382);
+ rule__ForSource__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1__1_in_rule__ForSource__Group_1_1__012385);
+ rule__ForSource__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1__0"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5896:1: rule__ForSource__Group_1_1__0__Impl : ( ( RULE_FORIN ) ) ;
+ public final void rule__ForSource__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5900:1: ( ( ( RULE_FORIN ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5901:1: ( ( RULE_FORIN ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5901:1: ( ( RULE_FORIN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5902:1: ( RULE_FORIN )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5903:1: ( RULE_FORIN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5903:3: RULE_FORIN
+ {
+ match(input,RULE_FORIN,FOLLOW_RULE_FORIN_in_rule__ForSource__Group_1_1__0__Impl12413); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5913:1: rule__ForSource__Group_1_1__1 : rule__ForSource__Group_1_1__1__Impl rule__ForSource__Group_1_1__2 ;
+ public final void rule__ForSource__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5917:1: ( rule__ForSource__Group_1_1__1__Impl rule__ForSource__Group_1_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5918:2: rule__ForSource__Group_1_1__1__Impl rule__ForSource__Group_1_1__2
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1__1__Impl_in_rule__ForSource__Group_1_1__112443);
+ rule__ForSource__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1__2_in_rule__ForSource__Group_1_1__112446);
+ rule__ForSource__Group_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1__1"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5925:1: rule__ForSource__Group_1_1__1__Impl : ( ( rule__ForSource__SourceAssignment_1_1_1 ) ) ;
+ public final void rule__ForSource__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5929:1: ( ( ( rule__ForSource__SourceAssignment_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5930:1: ( ( rule__ForSource__SourceAssignment_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5930:1: ( ( rule__ForSource__SourceAssignment_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5931:1: ( rule__ForSource__SourceAssignment_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getSourceAssignment_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5932:1: ( rule__ForSource__SourceAssignment_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5932:2: rule__ForSource__SourceAssignment_1_1_1
+ {
+ pushFollow(FOLLOW_rule__ForSource__SourceAssignment_1_1_1_in_rule__ForSource__Group_1_1__1__Impl12473);
+ rule__ForSource__SourceAssignment_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getSourceAssignment_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5942:1: rule__ForSource__Group_1_1__2 : rule__ForSource__Group_1_1__2__Impl ;
+ public final void rule__ForSource__Group_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5946:1: ( rule__ForSource__Group_1_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5947:2: rule__ForSource__Group_1_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1__2__Impl_in_rule__ForSource__Group_1_1__212503);
+ rule__ForSource__Group_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1__2"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5953:1: rule__ForSource__Group_1_1__2__Impl : ( ( rule__ForSource__Alternatives_1_1_2 )? ) ;
+ public final void rule__ForSource__Group_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5957:1: ( ( ( rule__ForSource__Alternatives_1_1_2 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5958:1: ( ( rule__ForSource__Alternatives_1_1_2 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5958:1: ( ( rule__ForSource__Alternatives_1_1_2 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5959:1: ( rule__ForSource__Alternatives_1_1_2 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getAlternatives_1_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5960:1: ( rule__ForSource__Alternatives_1_1_2 )?
+ int alt62=2;
+ int LA62_0 = input.LA(1);
+
+ if ( (LA62_0==RULE_WHEN) ) {
+ int LA62_1 = input.LA(2);
+
+ if ( (synpred95_InternalCakefile()) ) {
+ alt62=1;
+ }
+ }
+ else if ( (LA62_0==RULE_BY) ) {
+ int LA62_2 = input.LA(2);
+
+ if ( (synpred95_InternalCakefile()) ) {
+ alt62=1;
+ }
+ }
+ switch (alt62) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5960:2: rule__ForSource__Alternatives_1_1_2
+ {
+ pushFollow(FOLLOW_rule__ForSource__Alternatives_1_1_2_in_rule__ForSource__Group_1_1__2__Impl12530);
+ rule__ForSource__Alternatives_1_1_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getAlternatives_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5976:1: rule__ForSource__Group_1_1_2_0__0 : rule__ForSource__Group_1_1_2_0__0__Impl rule__ForSource__Group_1_1_2_0__1 ;
+ public final void rule__ForSource__Group_1_1_2_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5980:1: ( rule__ForSource__Group_1_1_2_0__0__Impl rule__ForSource__Group_1_1_2_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5981:2: rule__ForSource__Group_1_1_2_0__0__Impl rule__ForSource__Group_1_1_2_0__1
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0__0__Impl_in_rule__ForSource__Group_1_1_2_0__012567);
+ rule__ForSource__Group_1_1_2_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0__1_in_rule__ForSource__Group_1_1_2_0__012570);
+ rule__ForSource__Group_1_1_2_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0__0"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5988:1: rule__ForSource__Group_1_1_2_0__0__Impl : ( ( RULE_WHEN ) ) ;
+ public final void rule__ForSource__Group_1_1_2_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5992:1: ( ( ( RULE_WHEN ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5993:1: ( ( RULE_WHEN ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5993:1: ( ( RULE_WHEN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5994:1: ( RULE_WHEN )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5995:1: ( RULE_WHEN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5995:3: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rule__ForSource__Group_1_1_2_0__0__Impl12598); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0__0__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6005:1: rule__ForSource__Group_1_1_2_0__1 : rule__ForSource__Group_1_1_2_0__1__Impl rule__ForSource__Group_1_1_2_0__2 ;
+ public final void rule__ForSource__Group_1_1_2_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6009:1: ( rule__ForSource__Group_1_1_2_0__1__Impl rule__ForSource__Group_1_1_2_0__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6010:2: rule__ForSource__Group_1_1_2_0__1__Impl rule__ForSource__Group_1_1_2_0__2
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0__1__Impl_in_rule__ForSource__Group_1_1_2_0__112628);
+ rule__ForSource__Group_1_1_2_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0__2_in_rule__ForSource__Group_1_1_2_0__112631);
+ rule__ForSource__Group_1_1_2_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0__1"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6017:1: rule__ForSource__Group_1_1_2_0__1__Impl : ( ( rule__ForSource__WhenAssignment_1_1_2_0_1 ) ) ;
+ public final void rule__ForSource__Group_1_1_2_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6021:1: ( ( ( rule__ForSource__WhenAssignment_1_1_2_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6022:1: ( ( rule__ForSource__WhenAssignment_1_1_2_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6022:1: ( ( rule__ForSource__WhenAssignment_1_1_2_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6023:1: ( rule__ForSource__WhenAssignment_1_1_2_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6024:1: ( rule__ForSource__WhenAssignment_1_1_2_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6024:2: rule__ForSource__WhenAssignment_1_1_2_0_1
+ {
+ pushFollow(FOLLOW_rule__ForSource__WhenAssignment_1_1_2_0_1_in_rule__ForSource__Group_1_1_2_0__1__Impl12658);
+ rule__ForSource__WhenAssignment_1_1_2_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0__1__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6034:1: rule__ForSource__Group_1_1_2_0__2 : rule__ForSource__Group_1_1_2_0__2__Impl ;
+ public final void rule__ForSource__Group_1_1_2_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6038:1: ( rule__ForSource__Group_1_1_2_0__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6039:2: rule__ForSource__Group_1_1_2_0__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0__2__Impl_in_rule__ForSource__Group_1_1_2_0__212688);
+ rule__ForSource__Group_1_1_2_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0__2"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6045:1: rule__ForSource__Group_1_1_2_0__2__Impl : ( ( rule__ForSource__Group_1_1_2_0_2__0 )? ) ;
+ public final void rule__ForSource__Group_1_1_2_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6049:1: ( ( ( rule__ForSource__Group_1_1_2_0_2__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6050:1: ( ( rule__ForSource__Group_1_1_2_0_2__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6050:1: ( ( rule__ForSource__Group_1_1_2_0_2__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6051:1: ( rule__ForSource__Group_1_1_2_0_2__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getGroup_1_1_2_0_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6052:1: ( rule__ForSource__Group_1_1_2_0_2__0 )?
+ int alt63=2;
+ int LA63_0 = input.LA(1);
+
+ if ( (LA63_0==RULE_BY) ) {
+ int LA63_1 = input.LA(2);
+
+ if ( (synpred96_InternalCakefile()) ) {
+ alt63=1;
+ }
+ }
+ switch (alt63) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6052:2: rule__ForSource__Group_1_1_2_0_2__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0_2__0_in_rule__ForSource__Group_1_1_2_0__2__Impl12715);
+ rule__ForSource__Group_1_1_2_0_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getGroup_1_1_2_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0__2__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6068:1: rule__ForSource__Group_1_1_2_0_2__0 : rule__ForSource__Group_1_1_2_0_2__0__Impl rule__ForSource__Group_1_1_2_0_2__1 ;
+ public final void rule__ForSource__Group_1_1_2_0_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6072:1: ( rule__ForSource__Group_1_1_2_0_2__0__Impl rule__ForSource__Group_1_1_2_0_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6073:2: rule__ForSource__Group_1_1_2_0_2__0__Impl rule__ForSource__Group_1_1_2_0_2__1
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0_2__0__Impl_in_rule__ForSource__Group_1_1_2_0_2__012752);
+ rule__ForSource__Group_1_1_2_0_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0_2__1_in_rule__ForSource__Group_1_1_2_0_2__012755);
+ rule__ForSource__Group_1_1_2_0_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0_2__0"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6080:1: rule__ForSource__Group_1_1_2_0_2__0__Impl : ( ( RULE_BY ) ) ;
+ public final void rule__ForSource__Group_1_1_2_0_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6084:1: ( ( ( RULE_BY ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6085:1: ( ( RULE_BY ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6085:1: ( ( RULE_BY ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6086:1: ( RULE_BY )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6087:1: ( RULE_BY )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6087:3: RULE_BY
+ {
+ match(input,RULE_BY,FOLLOW_RULE_BY_in_rule__ForSource__Group_1_1_2_0_2__0__Impl12783); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0_2__0__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6097:1: rule__ForSource__Group_1_1_2_0_2__1 : rule__ForSource__Group_1_1_2_0_2__1__Impl ;
+ public final void rule__ForSource__Group_1_1_2_0_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6101:1: ( rule__ForSource__Group_1_1_2_0_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6102:2: rule__ForSource__Group_1_1_2_0_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0_2__1__Impl_in_rule__ForSource__Group_1_1_2_0_2__112813);
+ rule__ForSource__Group_1_1_2_0_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0_2__1"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_0_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6108:1: rule__ForSource__Group_1_1_2_0_2__1__Impl : ( ( rule__ForSource__ByAssignment_1_1_2_0_2_1 ) ) ;
+ public final void rule__ForSource__Group_1_1_2_0_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6112:1: ( ( ( rule__ForSource__ByAssignment_1_1_2_0_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6113:1: ( ( rule__ForSource__ByAssignment_1_1_2_0_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6113:1: ( ( rule__ForSource__ByAssignment_1_1_2_0_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6114:1: ( rule__ForSource__ByAssignment_1_1_2_0_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_0_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6115:1: ( rule__ForSource__ByAssignment_1_1_2_0_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6115:2: rule__ForSource__ByAssignment_1_1_2_0_2_1
+ {
+ pushFollow(FOLLOW_rule__ForSource__ByAssignment_1_1_2_0_2_1_in_rule__ForSource__Group_1_1_2_0_2__1__Impl12840);
+ rule__ForSource__ByAssignment_1_1_2_0_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_0_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_0_2__1__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6129:1: rule__ForSource__Group_1_1_2_1__0 : rule__ForSource__Group_1_1_2_1__0__Impl rule__ForSource__Group_1_1_2_1__1 ;
+ public final void rule__ForSource__Group_1_1_2_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6133:1: ( rule__ForSource__Group_1_1_2_1__0__Impl rule__ForSource__Group_1_1_2_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6134:2: rule__ForSource__Group_1_1_2_1__0__Impl rule__ForSource__Group_1_1_2_1__1
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1__0__Impl_in_rule__ForSource__Group_1_1_2_1__012874);
+ rule__ForSource__Group_1_1_2_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1__1_in_rule__ForSource__Group_1_1_2_1__012877);
+ rule__ForSource__Group_1_1_2_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1__0"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6141:1: rule__ForSource__Group_1_1_2_1__0__Impl : ( ( RULE_BY ) ) ;
+ public final void rule__ForSource__Group_1_1_2_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6145:1: ( ( ( RULE_BY ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6146:1: ( ( RULE_BY ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6146:1: ( ( RULE_BY ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6147:1: ( RULE_BY )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6148:1: ( RULE_BY )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6148:3: RULE_BY
+ {
+ match(input,RULE_BY,FOLLOW_RULE_BY_in_rule__ForSource__Group_1_1_2_1__0__Impl12905); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1__0__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6158:1: rule__ForSource__Group_1_1_2_1__1 : rule__ForSource__Group_1_1_2_1__1__Impl rule__ForSource__Group_1_1_2_1__2 ;
+ public final void rule__ForSource__Group_1_1_2_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6162:1: ( rule__ForSource__Group_1_1_2_1__1__Impl rule__ForSource__Group_1_1_2_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6163:2: rule__ForSource__Group_1_1_2_1__1__Impl rule__ForSource__Group_1_1_2_1__2
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1__1__Impl_in_rule__ForSource__Group_1_1_2_1__112935);
+ rule__ForSource__Group_1_1_2_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1__2_in_rule__ForSource__Group_1_1_2_1__112938);
+ rule__ForSource__Group_1_1_2_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1__1"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6170:1: rule__ForSource__Group_1_1_2_1__1__Impl : ( ( rule__ForSource__ByAssignment_1_1_2_1_1 ) ) ;
+ public final void rule__ForSource__Group_1_1_2_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6174:1: ( ( ( rule__ForSource__ByAssignment_1_1_2_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6175:1: ( ( rule__ForSource__ByAssignment_1_1_2_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6175:1: ( ( rule__ForSource__ByAssignment_1_1_2_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6176:1: ( rule__ForSource__ByAssignment_1_1_2_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6177:1: ( rule__ForSource__ByAssignment_1_1_2_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6177:2: rule__ForSource__ByAssignment_1_1_2_1_1
+ {
+ pushFollow(FOLLOW_rule__ForSource__ByAssignment_1_1_2_1_1_in_rule__ForSource__Group_1_1_2_1__1__Impl12965);
+ rule__ForSource__ByAssignment_1_1_2_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getByAssignment_1_1_2_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1__1__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6187:1: rule__ForSource__Group_1_1_2_1__2 : rule__ForSource__Group_1_1_2_1__2__Impl ;
+ public final void rule__ForSource__Group_1_1_2_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6191:1: ( rule__ForSource__Group_1_1_2_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6192:2: rule__ForSource__Group_1_1_2_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1__2__Impl_in_rule__ForSource__Group_1_1_2_1__212995);
+ rule__ForSource__Group_1_1_2_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1__2"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6198:1: rule__ForSource__Group_1_1_2_1__2__Impl : ( ( rule__ForSource__Group_1_1_2_1_2__0 )? ) ;
+ public final void rule__ForSource__Group_1_1_2_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6202:1: ( ( ( rule__ForSource__Group_1_1_2_1_2__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6203:1: ( ( rule__ForSource__Group_1_1_2_1_2__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6203:1: ( ( rule__ForSource__Group_1_1_2_1_2__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6204:1: ( rule__ForSource__Group_1_1_2_1_2__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getGroup_1_1_2_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6205:1: ( rule__ForSource__Group_1_1_2_1_2__0 )?
+ int alt64=2;
+ int LA64_0 = input.LA(1);
+
+ if ( (LA64_0==RULE_WHEN) ) {
+ int LA64_1 = input.LA(2);
+
+ if ( (synpred97_InternalCakefile()) ) {
+ alt64=1;
+ }
+ }
+ switch (alt64) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6205:2: rule__ForSource__Group_1_1_2_1_2__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1_2__0_in_rule__ForSource__Group_1_1_2_1__2__Impl13022);
+ rule__ForSource__Group_1_1_2_1_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getGroup_1_1_2_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1__2__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6221:1: rule__ForSource__Group_1_1_2_1_2__0 : rule__ForSource__Group_1_1_2_1_2__0__Impl rule__ForSource__Group_1_1_2_1_2__1 ;
+ public final void rule__ForSource__Group_1_1_2_1_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6225:1: ( rule__ForSource__Group_1_1_2_1_2__0__Impl rule__ForSource__Group_1_1_2_1_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6226:2: rule__ForSource__Group_1_1_2_1_2__0__Impl rule__ForSource__Group_1_1_2_1_2__1
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1_2__0__Impl_in_rule__ForSource__Group_1_1_2_1_2__013059);
+ rule__ForSource__Group_1_1_2_1_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1_2__1_in_rule__ForSource__Group_1_1_2_1_2__013062);
+ rule__ForSource__Group_1_1_2_1_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1_2__0"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6233:1: rule__ForSource__Group_1_1_2_1_2__0__Impl : ( ( RULE_WHEN ) ) ;
+ public final void rule__ForSource__Group_1_1_2_1_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6237:1: ( ( ( RULE_WHEN ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6238:1: ( ( RULE_WHEN ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6238:1: ( ( RULE_WHEN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6239:1: ( RULE_WHEN )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6240:1: ( RULE_WHEN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6240:3: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rule__ForSource__Group_1_1_2_1_2__0__Impl13090); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1_2__0__Impl"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6250:1: rule__ForSource__Group_1_1_2_1_2__1 : rule__ForSource__Group_1_1_2_1_2__1__Impl ;
+ public final void rule__ForSource__Group_1_1_2_1_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6254:1: ( rule__ForSource__Group_1_1_2_1_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6255:2: rule__ForSource__Group_1_1_2_1_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1_2__1__Impl_in_rule__ForSource__Group_1_1_2_1_2__113120);
+ rule__ForSource__Group_1_1_2_1_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1_2__1"
+
+
+ // $ANTLR start "rule__ForSource__Group_1_1_2_1_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6261:1: rule__ForSource__Group_1_1_2_1_2__1__Impl : ( ( rule__ForSource__WhenAssignment_1_1_2_1_2_1 ) ) ;
+ public final void rule__ForSource__Group_1_1_2_1_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6265:1: ( ( ( rule__ForSource__WhenAssignment_1_1_2_1_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6266:1: ( ( rule__ForSource__WhenAssignment_1_1_2_1_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6266:1: ( ( rule__ForSource__WhenAssignment_1_1_2_1_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6267:1: ( rule__ForSource__WhenAssignment_1_1_2_1_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_1_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6268:1: ( rule__ForSource__WhenAssignment_1_1_2_1_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6268:2: rule__ForSource__WhenAssignment_1_1_2_1_2_1
+ {
+ pushFollow(FOLLOW_rule__ForSource__WhenAssignment_1_1_2_1_2_1_in_rule__ForSource__Group_1_1_2_1_2__1__Impl13147);
+ rule__ForSource__WhenAssignment_1_1_2_1_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_1_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__Group_1_1_2_1_2__1__Impl"
+
+
+ // $ANTLR start "rule__Range__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6282:1: rule__Range__Group__0 : rule__Range__Group__0__Impl rule__Range__Group__1 ;
+ public final void rule__Range__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6286:1: ( rule__Range__Group__0__Impl rule__Range__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6287:2: rule__Range__Group__0__Impl rule__Range__Group__1
+ {
+ pushFollow(FOLLOW_rule__Range__Group__0__Impl_in_rule__Range__Group__013181);
+ rule__Range__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Range__Group__1_in_rule__Range__Group__013184);
+ rule__Range__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group__0"
+
+
+ // $ANTLR start "rule__Range__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6294:1: rule__Range__Group__0__Impl : ( ( rule__Range__Group_0__0 ) ) ;
+ public final void rule__Range__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6298:1: ( ( ( rule__Range__Group_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6299:1: ( ( rule__Range__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6299:1: ( ( rule__Range__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6300:1: ( rule__Range__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6301:1: ( rule__Range__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6301:2: rule__Range__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__Range__Group_0__0_in_rule__Range__Group__0__Impl13211);
+ rule__Range__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Range__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6311:1: rule__Range__Group__1 : rule__Range__Group__1__Impl rule__Range__Group__2 ;
+ public final void rule__Range__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6315:1: ( rule__Range__Group__1__Impl rule__Range__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6316:2: rule__Range__Group__1__Impl rule__Range__Group__2
+ {
+ pushFollow(FOLLOW_rule__Range__Group__1__Impl_in_rule__Range__Group__113241);
+ rule__Range__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Range__Group__2_in_rule__Range__Group__113244);
+ rule__Range__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group__1"
+
+
+ // $ANTLR start "rule__Range__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6323:1: rule__Range__Group__1__Impl : ( ( rule__Range__EndAssignment_1 ) ) ;
+ public final void rule__Range__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6327:1: ( ( ( rule__Range__EndAssignment_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6328:1: ( ( rule__Range__EndAssignment_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6328:1: ( ( rule__Range__EndAssignment_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6329:1: ( rule__Range__EndAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getEndAssignment_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6330:1: ( rule__Range__EndAssignment_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6330:2: rule__Range__EndAssignment_1
+ {
+ pushFollow(FOLLOW_rule__Range__EndAssignment_1_in_rule__Range__Group__1__Impl13271);
+ rule__Range__EndAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getEndAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Range__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6340:1: rule__Range__Group__2 : rule__Range__Group__2__Impl ;
+ public final void rule__Range__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6344:1: ( rule__Range__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6345:2: rule__Range__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Range__Group__2__Impl_in_rule__Range__Group__213301);
+ rule__Range__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group__2"
+
+
+ // $ANTLR start "rule__Range__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6351:1: rule__Range__Group__2__Impl : ( RULE_RBRACKET ) ;
+ public final void rule__Range__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6355:1: ( ( RULE_RBRACKET ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6356:1: ( RULE_RBRACKET )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6356:1: ( RULE_RBRACKET )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6357:1: RULE_RBRACKET
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2());
+ }
+ match(input,RULE_RBRACKET,FOLLOW_RULE_RBRACKET_in_rule__Range__Group__2__Impl13328); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group__2__Impl"
+
+
+ // $ANTLR start "rule__Range__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6374:1: rule__Range__Group_0__0 : rule__Range__Group_0__0__Impl ;
+ public final void rule__Range__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6378:1: ( rule__Range__Group_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6379:2: rule__Range__Group_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__Range__Group_0__0__Impl_in_rule__Range__Group_0__013363);
+ rule__Range__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group_0__0"
+
+
+ // $ANTLR start "rule__Range__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6385:1: rule__Range__Group_0__0__Impl : ( ( rule__Range__Group_0_0__0 ) ) ;
+ public final void rule__Range__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6389:1: ( ( ( rule__Range__Group_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6390:1: ( ( rule__Range__Group_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6390:1: ( ( rule__Range__Group_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6391:1: ( rule__Range__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getGroup_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6392:1: ( rule__Range__Group_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6392:2: rule__Range__Group_0_0__0
+ {
+ pushFollow(FOLLOW_rule__Range__Group_0_0__0_in_rule__Range__Group_0__0__Impl13390);
+ rule__Range__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__Range__Group_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6404:1: rule__Range__Group_0_0__0 : rule__Range__Group_0_0__0__Impl rule__Range__Group_0_0__1 ;
+ public final void rule__Range__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6408:1: ( rule__Range__Group_0_0__0__Impl rule__Range__Group_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6409:2: rule__Range__Group_0_0__0__Impl rule__Range__Group_0_0__1
+ {
+ pushFollow(FOLLOW_rule__Range__Group_0_0__0__Impl_in_rule__Range__Group_0_0__013422);
+ rule__Range__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Range__Group_0_0__1_in_rule__Range__Group_0_0__013425);
+ rule__Range__Group_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group_0_0__0"
+
+
+ // $ANTLR start "rule__Range__Group_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6416:1: rule__Range__Group_0_0__0__Impl : ( RULE_LBRACKET ) ;
+ public final void rule__Range__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6420:1: ( ( RULE_LBRACKET ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6421:1: ( RULE_LBRACKET )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6421:1: ( RULE_LBRACKET )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6422:1: RULE_LBRACKET
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0());
+ }
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_rule__Range__Group_0_0__0__Impl13452); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__Range__Group_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6433:1: rule__Range__Group_0_0__1 : rule__Range__Group_0_0__1__Impl rule__Range__Group_0_0__2 ;
+ public final void rule__Range__Group_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6437:1: ( rule__Range__Group_0_0__1__Impl rule__Range__Group_0_0__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6438:2: rule__Range__Group_0_0__1__Impl rule__Range__Group_0_0__2
+ {
+ pushFollow(FOLLOW_rule__Range__Group_0_0__1__Impl_in_rule__Range__Group_0_0__113481);
+ rule__Range__Group_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Range__Group_0_0__2_in_rule__Range__Group_0_0__113484);
+ rule__Range__Group_0_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group_0_0__1"
+
+
+ // $ANTLR start "rule__Range__Group_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6445:1: rule__Range__Group_0_0__1__Impl : ( ( rule__Range__StartAssignment_0_0_1 ) ) ;
+ public final void rule__Range__Group_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6449:1: ( ( ( rule__Range__StartAssignment_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6450:1: ( ( rule__Range__StartAssignment_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6450:1: ( ( rule__Range__StartAssignment_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6451:1: ( rule__Range__StartAssignment_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getStartAssignment_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6452:1: ( rule__Range__StartAssignment_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6452:2: rule__Range__StartAssignment_0_0_1
+ {
+ pushFollow(FOLLOW_rule__Range__StartAssignment_0_0_1_in_rule__Range__Group_0_0__1__Impl13511);
+ rule__Range__StartAssignment_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getStartAssignment_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__Range__Group_0_0__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6462:1: rule__Range__Group_0_0__2 : rule__Range__Group_0_0__2__Impl ;
+ public final void rule__Range__Group_0_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6466:1: ( rule__Range__Group_0_0__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6467:2: rule__Range__Group_0_0__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Range__Group_0_0__2__Impl_in_rule__Range__Group_0_0__213541);
+ rule__Range__Group_0_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group_0_0__2"
+
+
+ // $ANTLR start "rule__Range__Group_0_0__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6473:1: rule__Range__Group_0_0__2__Impl : ( ( rule__Range__Alternatives_0_0_2 ) ) ;
+ public final void rule__Range__Group_0_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6477:1: ( ( ( rule__Range__Alternatives_0_0_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6478:1: ( ( rule__Range__Alternatives_0_0_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6478:1: ( ( rule__Range__Alternatives_0_0_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6479:1: ( rule__Range__Alternatives_0_0_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getAlternatives_0_0_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6480:1: ( rule__Range__Alternatives_0_0_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6480:2: rule__Range__Alternatives_0_0_2
+ {
+ pushFollow(FOLLOW_rule__Range__Alternatives_0_0_2_in_rule__Range__Group_0_0__2__Impl13568);
+ rule__Range__Alternatives_0_0_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getAlternatives_0_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__Group_0_0__2__Impl"
+
+
+ // $ANTLR start "rule__Assignment__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6496:1: rule__Assignment__Group_0__0 : rule__Assignment__Group_0__0__Impl rule__Assignment__Group_0__1 ;
+ public final void rule__Assignment__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6500:1: ( rule__Assignment__Group_0__0__Impl rule__Assignment__Group_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6501:2: rule__Assignment__Group_0__0__Impl rule__Assignment__Group_0__1
+ {
+ pushFollow(FOLLOW_rule__Assignment__Group_0__0__Impl_in_rule__Assignment__Group_0__013604);
+ rule__Assignment__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Assignment__Group_0__1_in_rule__Assignment__Group_0__013607);
+ rule__Assignment__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0__0"
+
+
+ // $ANTLR start "rule__Assignment__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6508:1: rule__Assignment__Group_0__0__Impl : ( ( rule__Assignment__Group_0_0__0 ) ) ;
+ public final void rule__Assignment__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6512:1: ( ( ( rule__Assignment__Group_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6513:1: ( ( rule__Assignment__Group_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6513:1: ( ( rule__Assignment__Group_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6514:1: ( rule__Assignment__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getGroup_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6515:1: ( rule__Assignment__Group_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6515:2: rule__Assignment__Group_0_0__0
+ {
+ pushFollow(FOLLOW_rule__Assignment__Group_0_0__0_in_rule__Assignment__Group_0__0__Impl13634);
+ rule__Assignment__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__Assignment__Group_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6525:1: rule__Assignment__Group_0__1 : rule__Assignment__Group_0__1__Impl ;
+ public final void rule__Assignment__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6529:1: ( rule__Assignment__Group_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6530:2: rule__Assignment__Group_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Assignment__Group_0__1__Impl_in_rule__Assignment__Group_0__113664);
+ rule__Assignment__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0__1"
+
+
+ // $ANTLR start "rule__Assignment__Group_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6536:1: rule__Assignment__Group_0__1__Impl : ( ( rule__Assignment__RightAssignment_0_1 ) ) ;
+ public final void rule__Assignment__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6540:1: ( ( ( rule__Assignment__RightAssignment_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6541:1: ( ( rule__Assignment__RightAssignment_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6541:1: ( ( rule__Assignment__RightAssignment_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6542:1: ( rule__Assignment__RightAssignment_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getRightAssignment_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6543:1: ( rule__Assignment__RightAssignment_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6543:2: rule__Assignment__RightAssignment_0_1
+ {
+ pushFollow(FOLLOW_rule__Assignment__RightAssignment_0_1_in_rule__Assignment__Group_0__1__Impl13691);
+ rule__Assignment__RightAssignment_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getRightAssignment_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__Assignment__Group_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6557:1: rule__Assignment__Group_0_0__0 : rule__Assignment__Group_0_0__0__Impl ;
+ public final void rule__Assignment__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6561:1: ( rule__Assignment__Group_0_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6562:2: rule__Assignment__Group_0_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__Assignment__Group_0_0__0__Impl_in_rule__Assignment__Group_0_0__013725);
+ rule__Assignment__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0_0__0"
+
+
+ // $ANTLR start "rule__Assignment__Group_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6568:1: rule__Assignment__Group_0_0__0__Impl : ( ( rule__Assignment__Group_0_0_0__0 ) ) ;
+ public final void rule__Assignment__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6572:1: ( ( ( rule__Assignment__Group_0_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6573:1: ( ( rule__Assignment__Group_0_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6573:1: ( ( rule__Assignment__Group_0_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6574:1: ( rule__Assignment__Group_0_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getGroup_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6575:1: ( rule__Assignment__Group_0_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6575:2: rule__Assignment__Group_0_0_0__0
+ {
+ pushFollow(FOLLOW_rule__Assignment__Group_0_0_0__0_in_rule__Assignment__Group_0_0__0__Impl13752);
+ rule__Assignment__Group_0_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getGroup_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__Assignment__Group_0_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6587:1: rule__Assignment__Group_0_0_0__0 : rule__Assignment__Group_0_0_0__0__Impl rule__Assignment__Group_0_0_0__1 ;
+ public final void rule__Assignment__Group_0_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6591:1: ( rule__Assignment__Group_0_0_0__0__Impl rule__Assignment__Group_0_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6592:2: rule__Assignment__Group_0_0_0__0__Impl rule__Assignment__Group_0_0_0__1
+ {
+ pushFollow(FOLLOW_rule__Assignment__Group_0_0_0__0__Impl_in_rule__Assignment__Group_0_0_0__013784);
+ rule__Assignment__Group_0_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Assignment__Group_0_0_0__1_in_rule__Assignment__Group_0_0_0__013787);
+ rule__Assignment__Group_0_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0_0_0__0"
+
+
+ // $ANTLR start "rule__Assignment__Group_0_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6599:1: rule__Assignment__Group_0_0_0__0__Impl : ( ( rule__Assignment__LeftAssignment_0_0_0_0 ) ) ;
+ public final void rule__Assignment__Group_0_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6603:1: ( ( ( rule__Assignment__LeftAssignment_0_0_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6604:1: ( ( rule__Assignment__LeftAssignment_0_0_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6604:1: ( ( rule__Assignment__LeftAssignment_0_0_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6605:1: ( rule__Assignment__LeftAssignment_0_0_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getLeftAssignment_0_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6606:1: ( rule__Assignment__LeftAssignment_0_0_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6606:2: rule__Assignment__LeftAssignment_0_0_0_0
+ {
+ pushFollow(FOLLOW_rule__Assignment__LeftAssignment_0_0_0_0_in_rule__Assignment__Group_0_0_0__0__Impl13814);
+ rule__Assignment__LeftAssignment_0_0_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getLeftAssignment_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__Assignment__Group_0_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6616:1: rule__Assignment__Group_0_0_0__1 : rule__Assignment__Group_0_0_0__1__Impl ;
+ public final void rule__Assignment__Group_0_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6620:1: ( rule__Assignment__Group_0_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6621:2: rule__Assignment__Group_0_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Assignment__Group_0_0_0__1__Impl_in_rule__Assignment__Group_0_0_0__113844);
+ rule__Assignment__Group_0_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0_0_0__1"
+
+
+ // $ANTLR start "rule__Assignment__Group_0_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6627:1: rule__Assignment__Group_0_0_0__1__Impl : ( ( rule__Assignment__OperatorAssignment_0_0_0_1 ) ) ;
+ public final void rule__Assignment__Group_0_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6631:1: ( ( ( rule__Assignment__OperatorAssignment_0_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6632:1: ( ( rule__Assignment__OperatorAssignment_0_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6632:1: ( ( rule__Assignment__OperatorAssignment_0_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6633:1: ( rule__Assignment__OperatorAssignment_0_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getOperatorAssignment_0_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6634:1: ( rule__Assignment__OperatorAssignment_0_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6634:2: rule__Assignment__OperatorAssignment_0_0_0_1
+ {
+ pushFollow(FOLLOW_rule__Assignment__OperatorAssignment_0_0_0_1_in_rule__Assignment__Group_0_0_0__1__Impl13871);
+ rule__Assignment__OperatorAssignment_0_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getOperatorAssignment_0_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__Group_0_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__Assigned__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6648:1: rule__Assigned__Group_1__0 : rule__Assigned__Group_1__0__Impl rule__Assigned__Group_1__1 ;
+ public final void rule__Assigned__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6652:1: ( rule__Assigned__Group_1__0__Impl rule__Assigned__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6653:2: rule__Assigned__Group_1__0__Impl rule__Assigned__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__Assigned__Group_1__0__Impl_in_rule__Assigned__Group_1__013905);
+ rule__Assigned__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Assigned__Group_1__1_in_rule__Assigned__Group_1__013908);
+ rule__Assigned__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assigned__Group_1__0"
+
+
+ // $ANTLR start "rule__Assigned__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6660:1: rule__Assigned__Group_1__0__Impl : ( RULE_INDENT ) ;
+ public final void rule__Assigned__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6664:1: ( ( RULE_INDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6665:1: ( RULE_INDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6665:1: ( RULE_INDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6666:1: RULE_INDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0());
+ }
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rule__Assigned__Group_1__0__Impl13935); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assigned__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__Assigned__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6677:1: rule__Assigned__Group_1__1 : rule__Assigned__Group_1__1__Impl rule__Assigned__Group_1__2 ;
+ public final void rule__Assigned__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6681:1: ( rule__Assigned__Group_1__1__Impl rule__Assigned__Group_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6682:2: rule__Assigned__Group_1__1__Impl rule__Assigned__Group_1__2
+ {
+ pushFollow(FOLLOW_rule__Assigned__Group_1__1__Impl_in_rule__Assigned__Group_1__113964);
+ rule__Assigned__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Assigned__Group_1__2_in_rule__Assigned__Group_1__113967);
+ rule__Assigned__Group_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assigned__Group_1__1"
+
+
+ // $ANTLR start "rule__Assigned__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6689:1: rule__Assigned__Group_1__1__Impl : ( ruleExpression ) ;
+ public final void rule__Assigned__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6693:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6694:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6694:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6695:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Assigned__Group_1__1__Impl13994);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assigned__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__Assigned__Group_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6706:1: rule__Assigned__Group_1__2 : rule__Assigned__Group_1__2__Impl ;
+ public final void rule__Assigned__Group_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6710:1: ( rule__Assigned__Group_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6711:2: rule__Assigned__Group_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Assigned__Group_1__2__Impl_in_rule__Assigned__Group_1__214023);
+ rule__Assigned__Group_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assigned__Group_1__2"
+
+
+ // $ANTLR start "rule__Assigned__Group_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6717:1: rule__Assigned__Group_1__2__Impl : ( RULE_OUTDENT ) ;
+ public final void rule__Assigned__Group_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6721:1: ( ( RULE_OUTDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6722:1: ( RULE_OUTDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6722:1: ( RULE_OUTDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6723:1: RULE_OUTDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2());
+ }
+ match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rule__Assigned__Group_1__2__Impl14050); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assigned__Group_1__2__Impl"
+
+
+ // $ANTLR start "rule__LogicOp__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6740:1: rule__LogicOp__Group__0 : rule__LogicOp__Group__0__Impl rule__LogicOp__Group__1 ;
+ public final void rule__LogicOp__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6744:1: ( rule__LogicOp__Group__0__Impl rule__LogicOp__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6745:2: rule__LogicOp__Group__0__Impl rule__LogicOp__Group__1
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group__0__Impl_in_rule__LogicOp__Group__014085);
+ rule__LogicOp__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__LogicOp__Group__1_in_rule__LogicOp__Group__014088);
+ rule__LogicOp__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group__0"
+
+
+ // $ANTLR start "rule__LogicOp__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6752:1: rule__LogicOp__Group__0__Impl : ( ruleCompareOp ) ;
+ public final void rule__LogicOp__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6756:1: ( ( ruleCompareOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6757:1: ( ruleCompareOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6757:1: ( ruleCompareOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6758:1: ruleCompareOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleCompareOp_in_rule__LogicOp__Group__0__Impl14115);
+ ruleCompareOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group__0__Impl"
+
+
+ // $ANTLR start "rule__LogicOp__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6769:1: rule__LogicOp__Group__1 : rule__LogicOp__Group__1__Impl ;
+ public final void rule__LogicOp__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6773:1: ( rule__LogicOp__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6774:2: rule__LogicOp__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group__1__Impl_in_rule__LogicOp__Group__114144);
+ rule__LogicOp__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group__1"
+
+
+ // $ANTLR start "rule__LogicOp__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6780:1: rule__LogicOp__Group__1__Impl : ( ( rule__LogicOp__Group_1__0 )* ) ;
+ public final void rule__LogicOp__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6784:1: ( ( ( rule__LogicOp__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6785:1: ( ( rule__LogicOp__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6785:1: ( ( rule__LogicOp__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6786:1: ( rule__LogicOp__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6787:1: ( rule__LogicOp__Group_1__0 )*
+ loop65:
+ do {
+ int alt65=2;
+ int LA65_0 = input.LA(1);
+
+ if ( (LA65_0==RULE_LOGIC) ) {
+ int LA65_2 = input.LA(2);
+
+ if ( (synpred98_InternalCakefile()) ) {
+ alt65=1;
+ }
+
+
+ }
+
+
+ switch (alt65) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6787:2: rule__LogicOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group_1__0_in_rule__LogicOp__Group__1__Impl14171);
+ rule__LogicOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop65;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group__1__Impl"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6801:1: rule__LogicOp__Group_1__0 : rule__LogicOp__Group_1__0__Impl rule__LogicOp__Group_1__1 ;
+ public final void rule__LogicOp__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6805:1: ( rule__LogicOp__Group_1__0__Impl rule__LogicOp__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6806:2: rule__LogicOp__Group_1__0__Impl rule__LogicOp__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group_1__0__Impl_in_rule__LogicOp__Group_1__014206);
+ rule__LogicOp__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__LogicOp__Group_1__1_in_rule__LogicOp__Group_1__014209);
+ rule__LogicOp__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1__0"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6813:1: rule__LogicOp__Group_1__0__Impl : ( ( rule__LogicOp__Group_1_0__0 ) ) ;
+ public final void rule__LogicOp__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6817:1: ( ( ( rule__LogicOp__Group_1_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6818:1: ( ( rule__LogicOp__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6818:1: ( ( rule__LogicOp__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6819:1: ( rule__LogicOp__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6820:1: ( rule__LogicOp__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6820:2: rule__LogicOp__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group_1_0__0_in_rule__LogicOp__Group_1__0__Impl14236);
+ rule__LogicOp__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6830:1: rule__LogicOp__Group_1__1 : rule__LogicOp__Group_1__1__Impl ;
+ public final void rule__LogicOp__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6834:1: ( rule__LogicOp__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6835:2: rule__LogicOp__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group_1__1__Impl_in_rule__LogicOp__Group_1__114266);
+ rule__LogicOp__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1__1"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6841:1: rule__LogicOp__Group_1__1__Impl : ( ( rule__LogicOp__RightAssignment_1_1 ) ) ;
+ public final void rule__LogicOp__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6845:1: ( ( ( rule__LogicOp__RightAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6846:1: ( ( rule__LogicOp__RightAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6846:1: ( ( rule__LogicOp__RightAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6847:1: ( rule__LogicOp__RightAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getRightAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6848:1: ( rule__LogicOp__RightAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6848:2: rule__LogicOp__RightAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__LogicOp__RightAssignment_1_1_in_rule__LogicOp__Group_1__1__Impl14293);
+ rule__LogicOp__RightAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getRightAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6862:1: rule__LogicOp__Group_1_0__0 : rule__LogicOp__Group_1_0__0__Impl ;
+ public final void rule__LogicOp__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6866:1: ( rule__LogicOp__Group_1_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6867:2: rule__LogicOp__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group_1_0__0__Impl_in_rule__LogicOp__Group_1_0__014327);
+ rule__LogicOp__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1_0__0"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6873:1: rule__LogicOp__Group_1_0__0__Impl : ( ( rule__LogicOp__Group_1_0_0__0 ) ) ;
+ public final void rule__LogicOp__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6877:1: ( ( ( rule__LogicOp__Group_1_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6878:1: ( ( rule__LogicOp__Group_1_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6878:1: ( ( rule__LogicOp__Group_1_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6879:1: ( rule__LogicOp__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getGroup_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6880:1: ( rule__LogicOp__Group_1_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6880:2: rule__LogicOp__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group_1_0_0__0_in_rule__LogicOp__Group_1_0__0__Impl14354);
+ rule__LogicOp__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6892:1: rule__LogicOp__Group_1_0_0__0 : rule__LogicOp__Group_1_0_0__0__Impl rule__LogicOp__Group_1_0_0__1 ;
+ public final void rule__LogicOp__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6896:1: ( rule__LogicOp__Group_1_0_0__0__Impl rule__LogicOp__Group_1_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6897:2: rule__LogicOp__Group_1_0_0__0__Impl rule__LogicOp__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group_1_0_0__0__Impl_in_rule__LogicOp__Group_1_0_0__014386);
+ rule__LogicOp__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__LogicOp__Group_1_0_0__1_in_rule__LogicOp__Group_1_0_0__014389);
+ rule__LogicOp__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6904:1: rule__LogicOp__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__LogicOp__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6908:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6909:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6909:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6910:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6911:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6913:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6923:1: rule__LogicOp__Group_1_0_0__1 : rule__LogicOp__Group_1_0_0__1__Impl ;
+ public final void rule__LogicOp__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6927:1: ( rule__LogicOp__Group_1_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6928:2: rule__LogicOp__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group_1_0_0__1__Impl_in_rule__LogicOp__Group_1_0_0__114447);
+ rule__LogicOp__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__LogicOp__Group_1_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6934:1: rule__LogicOp__Group_1_0_0__1__Impl : ( ( rule__LogicOp__OperatorAssignment_1_0_0_1 ) ) ;
+ public final void rule__LogicOp__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6938:1: ( ( ( rule__LogicOp__OperatorAssignment_1_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6939:1: ( ( rule__LogicOp__OperatorAssignment_1_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6939:1: ( ( rule__LogicOp__OperatorAssignment_1_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6940:1: ( rule__LogicOp__OperatorAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6941:1: ( rule__LogicOp__OperatorAssignment_1_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6941:2: rule__LogicOp__OperatorAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_rule__LogicOp__OperatorAssignment_1_0_0_1_in_rule__LogicOp__Group_1_0_0__1__Impl14474);
+ rule__LogicOp__OperatorAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__CompareOp__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6955:1: rule__CompareOp__Group__0 : rule__CompareOp__Group__0__Impl rule__CompareOp__Group__1 ;
+ public final void rule__CompareOp__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6959:1: ( rule__CompareOp__Group__0__Impl rule__CompareOp__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6960:2: rule__CompareOp__Group__0__Impl rule__CompareOp__Group__1
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group__0__Impl_in_rule__CompareOp__Group__014508);
+ rule__CompareOp__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__CompareOp__Group__1_in_rule__CompareOp__Group__014511);
+ rule__CompareOp__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group__0"
+
+
+ // $ANTLR start "rule__CompareOp__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6967:1: rule__CompareOp__Group__0__Impl : ( ruleRelationOp ) ;
+ public final void rule__CompareOp__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6971:1: ( ( ruleRelationOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6972:1: ( ruleRelationOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6972:1: ( ruleRelationOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6973:1: ruleRelationOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleRelationOp_in_rule__CompareOp__Group__0__Impl14538);
+ ruleRelationOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group__0__Impl"
+
+
+ // $ANTLR start "rule__CompareOp__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6984:1: rule__CompareOp__Group__1 : rule__CompareOp__Group__1__Impl ;
+ public final void rule__CompareOp__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6988:1: ( rule__CompareOp__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6989:2: rule__CompareOp__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group__1__Impl_in_rule__CompareOp__Group__114567);
+ rule__CompareOp__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group__1"
+
+
+ // $ANTLR start "rule__CompareOp__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6995:1: rule__CompareOp__Group__1__Impl : ( ( rule__CompareOp__Group_1__0 )* ) ;
+ public final void rule__CompareOp__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6999:1: ( ( ( rule__CompareOp__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7000:1: ( ( rule__CompareOp__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7000:1: ( ( rule__CompareOp__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7001:1: ( rule__CompareOp__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7002:1: ( rule__CompareOp__Group_1__0 )*
+ loop66:
+ do {
+ int alt66=2;
+ int LA66_0 = input.LA(1);
+
+ if ( (LA66_0==RULE_COMPARE) ) {
+ int LA66_2 = input.LA(2);
+
+ if ( (synpred99_InternalCakefile()) ) {
+ alt66=1;
+ }
+
+
+ }
+
+
+ switch (alt66) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7002:2: rule__CompareOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group_1__0_in_rule__CompareOp__Group__1__Impl14594);
+ rule__CompareOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop66;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group__1__Impl"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7016:1: rule__CompareOp__Group_1__0 : rule__CompareOp__Group_1__0__Impl rule__CompareOp__Group_1__1 ;
+ public final void rule__CompareOp__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7020:1: ( rule__CompareOp__Group_1__0__Impl rule__CompareOp__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7021:2: rule__CompareOp__Group_1__0__Impl rule__CompareOp__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group_1__0__Impl_in_rule__CompareOp__Group_1__014629);
+ rule__CompareOp__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__CompareOp__Group_1__1_in_rule__CompareOp__Group_1__014632);
+ rule__CompareOp__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1__0"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7028:1: rule__CompareOp__Group_1__0__Impl : ( ( rule__CompareOp__Group_1_0__0 ) ) ;
+ public final void rule__CompareOp__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7032:1: ( ( ( rule__CompareOp__Group_1_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7033:1: ( ( rule__CompareOp__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7033:1: ( ( rule__CompareOp__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7034:1: ( rule__CompareOp__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7035:1: ( rule__CompareOp__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7035:2: rule__CompareOp__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group_1_0__0_in_rule__CompareOp__Group_1__0__Impl14659);
+ rule__CompareOp__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7045:1: rule__CompareOp__Group_1__1 : rule__CompareOp__Group_1__1__Impl ;
+ public final void rule__CompareOp__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7049:1: ( rule__CompareOp__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7050:2: rule__CompareOp__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group_1__1__Impl_in_rule__CompareOp__Group_1__114689);
+ rule__CompareOp__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1__1"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7056:1: rule__CompareOp__Group_1__1__Impl : ( ( rule__CompareOp__RightAssignment_1_1 ) ) ;
+ public final void rule__CompareOp__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7060:1: ( ( ( rule__CompareOp__RightAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7061:1: ( ( rule__CompareOp__RightAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7061:1: ( ( rule__CompareOp__RightAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7062:1: ( rule__CompareOp__RightAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getRightAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7063:1: ( rule__CompareOp__RightAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7063:2: rule__CompareOp__RightAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__CompareOp__RightAssignment_1_1_in_rule__CompareOp__Group_1__1__Impl14716);
+ rule__CompareOp__RightAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getRightAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7077:1: rule__CompareOp__Group_1_0__0 : rule__CompareOp__Group_1_0__0__Impl ;
+ public final void rule__CompareOp__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7081:1: ( rule__CompareOp__Group_1_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7082:2: rule__CompareOp__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group_1_0__0__Impl_in_rule__CompareOp__Group_1_0__014750);
+ rule__CompareOp__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1_0__0"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7088:1: rule__CompareOp__Group_1_0__0__Impl : ( ( rule__CompareOp__Group_1_0_0__0 ) ) ;
+ public final void rule__CompareOp__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7092:1: ( ( ( rule__CompareOp__Group_1_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7093:1: ( ( rule__CompareOp__Group_1_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7093:1: ( ( rule__CompareOp__Group_1_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7094:1: ( rule__CompareOp__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getGroup_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7095:1: ( rule__CompareOp__Group_1_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7095:2: rule__CompareOp__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group_1_0_0__0_in_rule__CompareOp__Group_1_0__0__Impl14777);
+ rule__CompareOp__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7107:1: rule__CompareOp__Group_1_0_0__0 : rule__CompareOp__Group_1_0_0__0__Impl rule__CompareOp__Group_1_0_0__1 ;
+ public final void rule__CompareOp__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7111:1: ( rule__CompareOp__Group_1_0_0__0__Impl rule__CompareOp__Group_1_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7112:2: rule__CompareOp__Group_1_0_0__0__Impl rule__CompareOp__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group_1_0_0__0__Impl_in_rule__CompareOp__Group_1_0_0__014809);
+ rule__CompareOp__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__CompareOp__Group_1_0_0__1_in_rule__CompareOp__Group_1_0_0__014812);
+ rule__CompareOp__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7119:1: rule__CompareOp__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__CompareOp__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7123:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7124:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7124:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7125:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7126:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7128:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7138:1: rule__CompareOp__Group_1_0_0__1 : rule__CompareOp__Group_1_0_0__1__Impl ;
+ public final void rule__CompareOp__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7142:1: ( rule__CompareOp__Group_1_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7143:2: rule__CompareOp__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group_1_0_0__1__Impl_in_rule__CompareOp__Group_1_0_0__114870);
+ rule__CompareOp__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__CompareOp__Group_1_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7149:1: rule__CompareOp__Group_1_0_0__1__Impl : ( ( rule__CompareOp__OperatorAssignment_1_0_0_1 ) ) ;
+ public final void rule__CompareOp__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7153:1: ( ( ( rule__CompareOp__OperatorAssignment_1_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7154:1: ( ( rule__CompareOp__OperatorAssignment_1_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7154:1: ( ( rule__CompareOp__OperatorAssignment_1_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7155:1: ( rule__CompareOp__OperatorAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7156:1: ( rule__CompareOp__OperatorAssignment_1_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7156:2: rule__CompareOp__OperatorAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_rule__CompareOp__OperatorAssignment_1_0_0_1_in_rule__CompareOp__Group_1_0_0__1__Impl14897);
+ rule__CompareOp__OperatorAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__RelationOp__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7170:1: rule__RelationOp__Group__0 : rule__RelationOp__Group__0__Impl rule__RelationOp__Group__1 ;
+ public final void rule__RelationOp__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7174:1: ( rule__RelationOp__Group__0__Impl rule__RelationOp__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7175:2: rule__RelationOp__Group__0__Impl rule__RelationOp__Group__1
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group__0__Impl_in_rule__RelationOp__Group__014931);
+ rule__RelationOp__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__RelationOp__Group__1_in_rule__RelationOp__Group__014934);
+ rule__RelationOp__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group__0"
+
+
+ // $ANTLR start "rule__RelationOp__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7182:1: rule__RelationOp__Group__0__Impl : ( ruleShiftOp ) ;
+ public final void rule__RelationOp__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7186:1: ( ( ruleShiftOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7187:1: ( ruleShiftOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7187:1: ( ruleShiftOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7188:1: ruleShiftOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleShiftOp_in_rule__RelationOp__Group__0__Impl14961);
+ ruleShiftOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group__0__Impl"
+
+
+ // $ANTLR start "rule__RelationOp__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7199:1: rule__RelationOp__Group__1 : rule__RelationOp__Group__1__Impl ;
+ public final void rule__RelationOp__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7203:1: ( rule__RelationOp__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7204:2: rule__RelationOp__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group__1__Impl_in_rule__RelationOp__Group__114990);
+ rule__RelationOp__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group__1"
+
+
+ // $ANTLR start "rule__RelationOp__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7210:1: rule__RelationOp__Group__1__Impl : ( ( rule__RelationOp__Group_1__0 )* ) ;
+ public final void rule__RelationOp__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7214:1: ( ( ( rule__RelationOp__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7215:1: ( ( rule__RelationOp__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7215:1: ( ( rule__RelationOp__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7216:1: ( rule__RelationOp__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7217:1: ( rule__RelationOp__Group_1__0 )*
+ loop67:
+ do {
+ int alt67=2;
+ int LA67_0 = input.LA(1);
+
+ if ( (LA67_0==RULE_RELATION) ) {
+ int LA67_2 = input.LA(2);
+
+ if ( (synpred100_InternalCakefile()) ) {
+ alt67=1;
+ }
+
+
+ }
+
+
+ switch (alt67) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7217:2: rule__RelationOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group_1__0_in_rule__RelationOp__Group__1__Impl15017);
+ rule__RelationOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop67;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group__1__Impl"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7231:1: rule__RelationOp__Group_1__0 : rule__RelationOp__Group_1__0__Impl rule__RelationOp__Group_1__1 ;
+ public final void rule__RelationOp__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7235:1: ( rule__RelationOp__Group_1__0__Impl rule__RelationOp__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7236:2: rule__RelationOp__Group_1__0__Impl rule__RelationOp__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group_1__0__Impl_in_rule__RelationOp__Group_1__015052);
+ rule__RelationOp__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__RelationOp__Group_1__1_in_rule__RelationOp__Group_1__015055);
+ rule__RelationOp__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1__0"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7243:1: rule__RelationOp__Group_1__0__Impl : ( ( rule__RelationOp__Group_1_0__0 ) ) ;
+ public final void rule__RelationOp__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7247:1: ( ( ( rule__RelationOp__Group_1_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7248:1: ( ( rule__RelationOp__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7248:1: ( ( rule__RelationOp__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7249:1: ( rule__RelationOp__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7250:1: ( rule__RelationOp__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7250:2: rule__RelationOp__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group_1_0__0_in_rule__RelationOp__Group_1__0__Impl15082);
+ rule__RelationOp__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7260:1: rule__RelationOp__Group_1__1 : rule__RelationOp__Group_1__1__Impl ;
+ public final void rule__RelationOp__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7264:1: ( rule__RelationOp__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7265:2: rule__RelationOp__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group_1__1__Impl_in_rule__RelationOp__Group_1__115112);
+ rule__RelationOp__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1__1"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7271:1: rule__RelationOp__Group_1__1__Impl : ( ( rule__RelationOp__RightAssignment_1_1 ) ) ;
+ public final void rule__RelationOp__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7275:1: ( ( ( rule__RelationOp__RightAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7276:1: ( ( rule__RelationOp__RightAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7276:1: ( ( rule__RelationOp__RightAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7277:1: ( rule__RelationOp__RightAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getRightAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7278:1: ( rule__RelationOp__RightAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7278:2: rule__RelationOp__RightAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__RelationOp__RightAssignment_1_1_in_rule__RelationOp__Group_1__1__Impl15139);
+ rule__RelationOp__RightAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getRightAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7292:1: rule__RelationOp__Group_1_0__0 : rule__RelationOp__Group_1_0__0__Impl ;
+ public final void rule__RelationOp__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7296:1: ( rule__RelationOp__Group_1_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7297:2: rule__RelationOp__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group_1_0__0__Impl_in_rule__RelationOp__Group_1_0__015173);
+ rule__RelationOp__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1_0__0"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7303:1: rule__RelationOp__Group_1_0__0__Impl : ( ( rule__RelationOp__Group_1_0_0__0 ) ) ;
+ public final void rule__RelationOp__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7307:1: ( ( ( rule__RelationOp__Group_1_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7308:1: ( ( rule__RelationOp__Group_1_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7308:1: ( ( rule__RelationOp__Group_1_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7309:1: ( rule__RelationOp__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getGroup_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7310:1: ( rule__RelationOp__Group_1_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7310:2: rule__RelationOp__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group_1_0_0__0_in_rule__RelationOp__Group_1_0__0__Impl15200);
+ rule__RelationOp__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7322:1: rule__RelationOp__Group_1_0_0__0 : rule__RelationOp__Group_1_0_0__0__Impl rule__RelationOp__Group_1_0_0__1 ;
+ public final void rule__RelationOp__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7326:1: ( rule__RelationOp__Group_1_0_0__0__Impl rule__RelationOp__Group_1_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7327:2: rule__RelationOp__Group_1_0_0__0__Impl rule__RelationOp__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group_1_0_0__0__Impl_in_rule__RelationOp__Group_1_0_0__015232);
+ rule__RelationOp__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__RelationOp__Group_1_0_0__1_in_rule__RelationOp__Group_1_0_0__015235);
+ rule__RelationOp__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7334:1: rule__RelationOp__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__RelationOp__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7338:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7339:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7339:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7340:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7341:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7343:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7353:1: rule__RelationOp__Group_1_0_0__1 : rule__RelationOp__Group_1_0_0__1__Impl ;
+ public final void rule__RelationOp__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7357:1: ( rule__RelationOp__Group_1_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7358:2: rule__RelationOp__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group_1_0_0__1__Impl_in_rule__RelationOp__Group_1_0_0__115293);
+ rule__RelationOp__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__RelationOp__Group_1_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7364:1: rule__RelationOp__Group_1_0_0__1__Impl : ( ( rule__RelationOp__OperatorAssignment_1_0_0_1 ) ) ;
+ public final void rule__RelationOp__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7368:1: ( ( ( rule__RelationOp__OperatorAssignment_1_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7369:1: ( ( rule__RelationOp__OperatorAssignment_1_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7369:1: ( ( rule__RelationOp__OperatorAssignment_1_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7370:1: ( rule__RelationOp__OperatorAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7371:1: ( rule__RelationOp__OperatorAssignment_1_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7371:2: rule__RelationOp__OperatorAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_rule__RelationOp__OperatorAssignment_1_0_0_1_in_rule__RelationOp__Group_1_0_0__1__Impl15320);
+ rule__RelationOp__OperatorAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__ShiftOp__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7385:1: rule__ShiftOp__Group__0 : rule__ShiftOp__Group__0__Impl rule__ShiftOp__Group__1 ;
+ public final void rule__ShiftOp__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7389:1: ( rule__ShiftOp__Group__0__Impl rule__ShiftOp__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7390:2: rule__ShiftOp__Group__0__Impl rule__ShiftOp__Group__1
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group__0__Impl_in_rule__ShiftOp__Group__015354);
+ rule__ShiftOp__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ShiftOp__Group__1_in_rule__ShiftOp__Group__015357);
+ rule__ShiftOp__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group__0"
+
+
+ // $ANTLR start "rule__ShiftOp__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7397:1: rule__ShiftOp__Group__0__Impl : ( ruleAdditiveOp ) ;
+ public final void rule__ShiftOp__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7401:1: ( ( ruleAdditiveOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7402:1: ( ruleAdditiveOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7402:1: ( ruleAdditiveOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7403:1: ruleAdditiveOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleAdditiveOp_in_rule__ShiftOp__Group__0__Impl15384);
+ ruleAdditiveOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ShiftOp__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7414:1: rule__ShiftOp__Group__1 : rule__ShiftOp__Group__1__Impl ;
+ public final void rule__ShiftOp__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7418:1: ( rule__ShiftOp__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7419:2: rule__ShiftOp__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group__1__Impl_in_rule__ShiftOp__Group__115413);
+ rule__ShiftOp__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group__1"
+
+
+ // $ANTLR start "rule__ShiftOp__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7425:1: rule__ShiftOp__Group__1__Impl : ( ( rule__ShiftOp__Group_1__0 )* ) ;
+ public final void rule__ShiftOp__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7429:1: ( ( ( rule__ShiftOp__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7430:1: ( ( rule__ShiftOp__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7430:1: ( ( rule__ShiftOp__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7431:1: ( rule__ShiftOp__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7432:1: ( rule__ShiftOp__Group_1__0 )*
+ loop68:
+ do {
+ int alt68=2;
+ int LA68_0 = input.LA(1);
+
+ if ( (LA68_0==RULE_SHIFT) ) {
+ int LA68_2 = input.LA(2);
+
+ if ( (synpred101_InternalCakefile()) ) {
+ alt68=1;
+ }
+
+
+ }
+
+
+ switch (alt68) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7432:2: rule__ShiftOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1__0_in_rule__ShiftOp__Group__1__Impl15440);
+ rule__ShiftOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop68;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7446:1: rule__ShiftOp__Group_1__0 : rule__ShiftOp__Group_1__0__Impl rule__ShiftOp__Group_1__1 ;
+ public final void rule__ShiftOp__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7450:1: ( rule__ShiftOp__Group_1__0__Impl rule__ShiftOp__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7451:2: rule__ShiftOp__Group_1__0__Impl rule__ShiftOp__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1__0__Impl_in_rule__ShiftOp__Group_1__015475);
+ rule__ShiftOp__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1__1_in_rule__ShiftOp__Group_1__015478);
+ rule__ShiftOp__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1__0"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7458:1: rule__ShiftOp__Group_1__0__Impl : ( ( rule__ShiftOp__Group_1_0__0 ) ) ;
+ public final void rule__ShiftOp__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7462:1: ( ( ( rule__ShiftOp__Group_1_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7463:1: ( ( rule__ShiftOp__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7463:1: ( ( rule__ShiftOp__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7464:1: ( rule__ShiftOp__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7465:1: ( rule__ShiftOp__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7465:2: rule__ShiftOp__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1_0__0_in_rule__ShiftOp__Group_1__0__Impl15505);
+ rule__ShiftOp__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7475:1: rule__ShiftOp__Group_1__1 : rule__ShiftOp__Group_1__1__Impl ;
+ public final void rule__ShiftOp__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7479:1: ( rule__ShiftOp__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7480:2: rule__ShiftOp__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1__1__Impl_in_rule__ShiftOp__Group_1__115535);
+ rule__ShiftOp__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1__1"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7486:1: rule__ShiftOp__Group_1__1__Impl : ( ( rule__ShiftOp__RightAssignment_1_1 ) ) ;
+ public final void rule__ShiftOp__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7490:1: ( ( ( rule__ShiftOp__RightAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7491:1: ( ( rule__ShiftOp__RightAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7491:1: ( ( rule__ShiftOp__RightAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7492:1: ( rule__ShiftOp__RightAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getRightAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7493:1: ( rule__ShiftOp__RightAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7493:2: rule__ShiftOp__RightAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__RightAssignment_1_1_in_rule__ShiftOp__Group_1__1__Impl15562);
+ rule__ShiftOp__RightAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getRightAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7507:1: rule__ShiftOp__Group_1_0__0 : rule__ShiftOp__Group_1_0__0__Impl ;
+ public final void rule__ShiftOp__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7511:1: ( rule__ShiftOp__Group_1_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7512:2: rule__ShiftOp__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1_0__0__Impl_in_rule__ShiftOp__Group_1_0__015596);
+ rule__ShiftOp__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1_0__0"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7518:1: rule__ShiftOp__Group_1_0__0__Impl : ( ( rule__ShiftOp__Group_1_0_0__0 ) ) ;
+ public final void rule__ShiftOp__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7522:1: ( ( ( rule__ShiftOp__Group_1_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7523:1: ( ( rule__ShiftOp__Group_1_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7523:1: ( ( rule__ShiftOp__Group_1_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7524:1: ( rule__ShiftOp__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getGroup_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7525:1: ( rule__ShiftOp__Group_1_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7525:2: rule__ShiftOp__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1_0_0__0_in_rule__ShiftOp__Group_1_0__0__Impl15623);
+ rule__ShiftOp__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7537:1: rule__ShiftOp__Group_1_0_0__0 : rule__ShiftOp__Group_1_0_0__0__Impl rule__ShiftOp__Group_1_0_0__1 ;
+ public final void rule__ShiftOp__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7541:1: ( rule__ShiftOp__Group_1_0_0__0__Impl rule__ShiftOp__Group_1_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7542:2: rule__ShiftOp__Group_1_0_0__0__Impl rule__ShiftOp__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1_0_0__0__Impl_in_rule__ShiftOp__Group_1_0_0__015655);
+ rule__ShiftOp__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1_0_0__1_in_rule__ShiftOp__Group_1_0_0__015658);
+ rule__ShiftOp__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7549:1: rule__ShiftOp__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__ShiftOp__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7553:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7554:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7554:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7555:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7556:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7558:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7568:1: rule__ShiftOp__Group_1_0_0__1 : rule__ShiftOp__Group_1_0_0__1__Impl ;
+ public final void rule__ShiftOp__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7572:1: ( rule__ShiftOp__Group_1_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7573:2: rule__ShiftOp__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1_0_0__1__Impl_in_rule__ShiftOp__Group_1_0_0__115716);
+ rule__ShiftOp__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__ShiftOp__Group_1_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7579:1: rule__ShiftOp__Group_1_0_0__1__Impl : ( ( rule__ShiftOp__OperatorAssignment_1_0_0_1 ) ) ;
+ public final void rule__ShiftOp__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7583:1: ( ( ( rule__ShiftOp__OperatorAssignment_1_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7584:1: ( ( rule__ShiftOp__OperatorAssignment_1_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7584:1: ( ( rule__ShiftOp__OperatorAssignment_1_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7585:1: ( rule__ShiftOp__OperatorAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7586:1: ( rule__ShiftOp__OperatorAssignment_1_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7586:2: rule__ShiftOp__OperatorAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__OperatorAssignment_1_0_0_1_in_rule__ShiftOp__Group_1_0_0__1__Impl15743);
+ rule__ShiftOp__OperatorAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7600:1: rule__AdditiveOp__Group__0 : rule__AdditiveOp__Group__0__Impl rule__AdditiveOp__Group__1 ;
+ public final void rule__AdditiveOp__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7604:1: ( rule__AdditiveOp__Group__0__Impl rule__AdditiveOp__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7605:2: rule__AdditiveOp__Group__0__Impl rule__AdditiveOp__Group__1
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group__0__Impl_in_rule__AdditiveOp__Group__015777);
+ rule__AdditiveOp__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AdditiveOp__Group__1_in_rule__AdditiveOp__Group__015780);
+ rule__AdditiveOp__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group__0"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7612:1: rule__AdditiveOp__Group__0__Impl : ( ruleMathOp ) ;
+ public final void rule__AdditiveOp__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7616:1: ( ( ruleMathOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7617:1: ( ruleMathOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7617:1: ( ruleMathOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7618:1: ruleMathOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleMathOp_in_rule__AdditiveOp__Group__0__Impl15807);
+ ruleMathOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group__0__Impl"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7629:1: rule__AdditiveOp__Group__1 : rule__AdditiveOp__Group__1__Impl ;
+ public final void rule__AdditiveOp__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7633:1: ( rule__AdditiveOp__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7634:2: rule__AdditiveOp__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group__1__Impl_in_rule__AdditiveOp__Group__115836);
+ rule__AdditiveOp__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group__1"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7640:1: rule__AdditiveOp__Group__1__Impl : ( ( rule__AdditiveOp__Group_1__0 )* ) ;
+ public final void rule__AdditiveOp__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7644:1: ( ( ( rule__AdditiveOp__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7645:1: ( ( rule__AdditiveOp__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7645:1: ( ( rule__AdditiveOp__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7646:1: ( rule__AdditiveOp__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7647:1: ( rule__AdditiveOp__Group_1__0 )*
+ loop69:
+ do {
+ int alt69=2;
+ int LA69_0 = input.LA(1);
+
+ if ( (LA69_0==RULE_PLUS) ) {
+ int LA69_2 = input.LA(2);
+
+ if ( (synpred102_InternalCakefile()) ) {
+ alt69=1;
+ }
+
+
+ }
+ else if ( (LA69_0==RULE_MINUS) ) {
+ int LA69_3 = input.LA(2);
+
+ if ( (synpred102_InternalCakefile()) ) {
+ alt69=1;
+ }
+
+
+ }
+
+
+ switch (alt69) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7647:2: rule__AdditiveOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1__0_in_rule__AdditiveOp__Group__1__Impl15863);
+ rule__AdditiveOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop69;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group__1__Impl"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7661:1: rule__AdditiveOp__Group_1__0 : rule__AdditiveOp__Group_1__0__Impl rule__AdditiveOp__Group_1__1 ;
+ public final void rule__AdditiveOp__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7665:1: ( rule__AdditiveOp__Group_1__0__Impl rule__AdditiveOp__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7666:2: rule__AdditiveOp__Group_1__0__Impl rule__AdditiveOp__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1__0__Impl_in_rule__AdditiveOp__Group_1__015898);
+ rule__AdditiveOp__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1__1_in_rule__AdditiveOp__Group_1__015901);
+ rule__AdditiveOp__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1__0"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7673:1: rule__AdditiveOp__Group_1__0__Impl : ( ( rule__AdditiveOp__Group_1_0__0 ) ) ;
+ public final void rule__AdditiveOp__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7677:1: ( ( ( rule__AdditiveOp__Group_1_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7678:1: ( ( rule__AdditiveOp__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7678:1: ( ( rule__AdditiveOp__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7679:1: ( rule__AdditiveOp__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7680:1: ( rule__AdditiveOp__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7680:2: rule__AdditiveOp__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1_0__0_in_rule__AdditiveOp__Group_1__0__Impl15928);
+ rule__AdditiveOp__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7690:1: rule__AdditiveOp__Group_1__1 : rule__AdditiveOp__Group_1__1__Impl ;
+ public final void rule__AdditiveOp__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7694:1: ( rule__AdditiveOp__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7695:2: rule__AdditiveOp__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1__1__Impl_in_rule__AdditiveOp__Group_1__115958);
+ rule__AdditiveOp__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1__1"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7701:1: rule__AdditiveOp__Group_1__1__Impl : ( ( rule__AdditiveOp__RightAssignment_1_1 ) ) ;
+ public final void rule__AdditiveOp__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7705:1: ( ( ( rule__AdditiveOp__RightAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7706:1: ( ( rule__AdditiveOp__RightAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7706:1: ( ( rule__AdditiveOp__RightAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7707:1: ( rule__AdditiveOp__RightAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getRightAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7708:1: ( rule__AdditiveOp__RightAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7708:2: rule__AdditiveOp__RightAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__RightAssignment_1_1_in_rule__AdditiveOp__Group_1__1__Impl15985);
+ rule__AdditiveOp__RightAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getRightAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7722:1: rule__AdditiveOp__Group_1_0__0 : rule__AdditiveOp__Group_1_0__0__Impl ;
+ public final void rule__AdditiveOp__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7726:1: ( rule__AdditiveOp__Group_1_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7727:2: rule__AdditiveOp__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1_0__0__Impl_in_rule__AdditiveOp__Group_1_0__016019);
+ rule__AdditiveOp__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1_0__0"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7733:1: rule__AdditiveOp__Group_1_0__0__Impl : ( ( rule__AdditiveOp__Group_1_0_0__0 ) ) ;
+ public final void rule__AdditiveOp__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7737:1: ( ( ( rule__AdditiveOp__Group_1_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7738:1: ( ( rule__AdditiveOp__Group_1_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7738:1: ( ( rule__AdditiveOp__Group_1_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7739:1: ( rule__AdditiveOp__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getGroup_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7740:1: ( rule__AdditiveOp__Group_1_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7740:2: rule__AdditiveOp__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1_0_0__0_in_rule__AdditiveOp__Group_1_0__0__Impl16046);
+ rule__AdditiveOp__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7752:1: rule__AdditiveOp__Group_1_0_0__0 : rule__AdditiveOp__Group_1_0_0__0__Impl rule__AdditiveOp__Group_1_0_0__1 ;
+ public final void rule__AdditiveOp__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7756:1: ( rule__AdditiveOp__Group_1_0_0__0__Impl rule__AdditiveOp__Group_1_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7757:2: rule__AdditiveOp__Group_1_0_0__0__Impl rule__AdditiveOp__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1_0_0__0__Impl_in_rule__AdditiveOp__Group_1_0_0__016078);
+ rule__AdditiveOp__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1_0_0__1_in_rule__AdditiveOp__Group_1_0_0__016081);
+ rule__AdditiveOp__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7764:1: rule__AdditiveOp__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__AdditiveOp__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7768:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7769:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7769:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7770:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7771:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7773:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7783:1: rule__AdditiveOp__Group_1_0_0__1 : rule__AdditiveOp__Group_1_0_0__1__Impl ;
+ public final void rule__AdditiveOp__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7787:1: ( rule__AdditiveOp__Group_1_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7788:2: rule__AdditiveOp__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1_0_0__1__Impl_in_rule__AdditiveOp__Group_1_0_0__116139);
+ rule__AdditiveOp__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__AdditiveOp__Group_1_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7794:1: rule__AdditiveOp__Group_1_0_0__1__Impl : ( ( rule__AdditiveOp__OperatorAssignment_1_0_0_1 ) ) ;
+ public final void rule__AdditiveOp__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7798:1: ( ( ( rule__AdditiveOp__OperatorAssignment_1_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7799:1: ( ( rule__AdditiveOp__OperatorAssignment_1_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7799:1: ( ( rule__AdditiveOp__OperatorAssignment_1_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7800:1: ( rule__AdditiveOp__OperatorAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7801:1: ( rule__AdditiveOp__OperatorAssignment_1_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7801:2: rule__AdditiveOp__OperatorAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__OperatorAssignment_1_0_0_1_in_rule__AdditiveOp__Group_1_0_0__1__Impl16166);
+ rule__AdditiveOp__OperatorAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__MathOp__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7815:1: rule__MathOp__Group__0 : rule__MathOp__Group__0__Impl rule__MathOp__Group__1 ;
+ public final void rule__MathOp__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7819:1: ( rule__MathOp__Group__0__Impl rule__MathOp__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7820:2: rule__MathOp__Group__0__Impl rule__MathOp__Group__1
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group__0__Impl_in_rule__MathOp__Group__016200);
+ rule__MathOp__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__MathOp__Group__1_in_rule__MathOp__Group__016203);
+ rule__MathOp__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group__0"
+
+
+ // $ANTLR start "rule__MathOp__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7827:1: rule__MathOp__Group__0__Impl : ( ruleUnaryOp ) ;
+ public final void rule__MathOp__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7831:1: ( ( ruleUnaryOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7832:1: ( ruleUnaryOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7832:1: ( ruleUnaryOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7833:1: ruleUnaryOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleUnaryOp_in_rule__MathOp__Group__0__Impl16230);
+ ruleUnaryOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group__0__Impl"
+
+
+ // $ANTLR start "rule__MathOp__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7844:1: rule__MathOp__Group__1 : rule__MathOp__Group__1__Impl ;
+ public final void rule__MathOp__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7848:1: ( rule__MathOp__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7849:2: rule__MathOp__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group__1__Impl_in_rule__MathOp__Group__116259);
+ rule__MathOp__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group__1"
+
+
+ // $ANTLR start "rule__MathOp__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7855:1: rule__MathOp__Group__1__Impl : ( ( rule__MathOp__Group_1__0 )* ) ;
+ public final void rule__MathOp__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7859:1: ( ( ( rule__MathOp__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7860:1: ( ( rule__MathOp__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7860:1: ( ( rule__MathOp__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7861:1: ( rule__MathOp__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7862:1: ( rule__MathOp__Group_1__0 )*
+ loop70:
+ do {
+ int alt70=2;
+ int LA70_0 = input.LA(1);
+
+ if ( (LA70_0==RULE_MATH) ) {
+ int LA70_2 = input.LA(2);
+
+ if ( (synpred103_InternalCakefile()) ) {
+ alt70=1;
+ }
+
+
+ }
+
+
+ switch (alt70) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7862:2: rule__MathOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group_1__0_in_rule__MathOp__Group__1__Impl16286);
+ rule__MathOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop70;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group__1__Impl"
+
+
+ // $ANTLR start "rule__MathOp__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7876:1: rule__MathOp__Group_1__0 : rule__MathOp__Group_1__0__Impl rule__MathOp__Group_1__1 ;
+ public final void rule__MathOp__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7880:1: ( rule__MathOp__Group_1__0__Impl rule__MathOp__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7881:2: rule__MathOp__Group_1__0__Impl rule__MathOp__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group_1__0__Impl_in_rule__MathOp__Group_1__016321);
+ rule__MathOp__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__MathOp__Group_1__1_in_rule__MathOp__Group_1__016324);
+ rule__MathOp__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1__0"
+
+
+ // $ANTLR start "rule__MathOp__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7888:1: rule__MathOp__Group_1__0__Impl : ( ( rule__MathOp__Group_1_0__0 ) ) ;
+ public final void rule__MathOp__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7892:1: ( ( ( rule__MathOp__Group_1_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7893:1: ( ( rule__MathOp__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7893:1: ( ( rule__MathOp__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7894:1: ( rule__MathOp__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7895:1: ( rule__MathOp__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7895:2: rule__MathOp__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group_1_0__0_in_rule__MathOp__Group_1__0__Impl16351);
+ rule__MathOp__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__MathOp__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7905:1: rule__MathOp__Group_1__1 : rule__MathOp__Group_1__1__Impl ;
+ public final void rule__MathOp__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7909:1: ( rule__MathOp__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7910:2: rule__MathOp__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group_1__1__Impl_in_rule__MathOp__Group_1__116381);
+ rule__MathOp__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1__1"
+
+
+ // $ANTLR start "rule__MathOp__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7916:1: rule__MathOp__Group_1__1__Impl : ( ( rule__MathOp__RightAssignment_1_1 ) ) ;
+ public final void rule__MathOp__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7920:1: ( ( ( rule__MathOp__RightAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7921:1: ( ( rule__MathOp__RightAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7921:1: ( ( rule__MathOp__RightAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7922:1: ( rule__MathOp__RightAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getRightAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7923:1: ( rule__MathOp__RightAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7923:2: rule__MathOp__RightAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__MathOp__RightAssignment_1_1_in_rule__MathOp__Group_1__1__Impl16408);
+ rule__MathOp__RightAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getRightAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__MathOp__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7937:1: rule__MathOp__Group_1_0__0 : rule__MathOp__Group_1_0__0__Impl ;
+ public final void rule__MathOp__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7941:1: ( rule__MathOp__Group_1_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7942:2: rule__MathOp__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group_1_0__0__Impl_in_rule__MathOp__Group_1_0__016442);
+ rule__MathOp__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1_0__0"
+
+
+ // $ANTLR start "rule__MathOp__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7948:1: rule__MathOp__Group_1_0__0__Impl : ( ( rule__MathOp__Group_1_0_0__0 ) ) ;
+ public final void rule__MathOp__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7952:1: ( ( ( rule__MathOp__Group_1_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7953:1: ( ( rule__MathOp__Group_1_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7953:1: ( ( rule__MathOp__Group_1_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7954:1: ( rule__MathOp__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getGroup_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7955:1: ( rule__MathOp__Group_1_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7955:2: rule__MathOp__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group_1_0_0__0_in_rule__MathOp__Group_1_0__0__Impl16469);
+ rule__MathOp__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__MathOp__Group_1_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7967:1: rule__MathOp__Group_1_0_0__0 : rule__MathOp__Group_1_0_0__0__Impl rule__MathOp__Group_1_0_0__1 ;
+ public final void rule__MathOp__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7971:1: ( rule__MathOp__Group_1_0_0__0__Impl rule__MathOp__Group_1_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7972:2: rule__MathOp__Group_1_0_0__0__Impl rule__MathOp__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group_1_0_0__0__Impl_in_rule__MathOp__Group_1_0_0__016501);
+ rule__MathOp__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__MathOp__Group_1_0_0__1_in_rule__MathOp__Group_1_0_0__016504);
+ rule__MathOp__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__MathOp__Group_1_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7979:1: rule__MathOp__Group_1_0_0__0__Impl : ( () ) ;
+ public final void rule__MathOp__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7983:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7984:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7984:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7985:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7986:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7988:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__MathOp__Group_1_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7998:1: rule__MathOp__Group_1_0_0__1 : rule__MathOp__Group_1_0_0__1__Impl ;
+ public final void rule__MathOp__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8002:1: ( rule__MathOp__Group_1_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8003:2: rule__MathOp__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group_1_0_0__1__Impl_in_rule__MathOp__Group_1_0_0__116562);
+ rule__MathOp__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__MathOp__Group_1_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8009:1: rule__MathOp__Group_1_0_0__1__Impl : ( ( rule__MathOp__OperatorAssignment_1_0_0_1 ) ) ;
+ public final void rule__MathOp__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8013:1: ( ( ( rule__MathOp__OperatorAssignment_1_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8014:1: ( ( rule__MathOp__OperatorAssignment_1_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8014:1: ( ( rule__MathOp__OperatorAssignment_1_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8015:1: ( rule__MathOp__OperatorAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8016:1: ( rule__MathOp__OperatorAssignment_1_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8016:2: rule__MathOp__OperatorAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_rule__MathOp__OperatorAssignment_1_0_0_1_in_rule__MathOp__Group_1_0_0__1__Impl16589);
+ rule__MathOp__OperatorAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getOperatorAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8030:1: rule__UnaryOp__Group_0__0 : rule__UnaryOp__Group_0__0__Impl rule__UnaryOp__Group_0__1 ;
+ public final void rule__UnaryOp__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8034:1: ( rule__UnaryOp__Group_0__0__Impl rule__UnaryOp__Group_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8035:2: rule__UnaryOp__Group_0__0__Impl rule__UnaryOp__Group_0__1
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Group_0__0__Impl_in_rule__UnaryOp__Group_0__016623);
+ rule__UnaryOp__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__UnaryOp__Group_0__1_in_rule__UnaryOp__Group_0__016626);
+ rule__UnaryOp__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_0__0"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8042:1: rule__UnaryOp__Group_0__0__Impl : ( ( rule__UnaryOp__Alternatives_0_0 ) ) ;
+ public final void rule__UnaryOp__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8046:1: ( ( ( rule__UnaryOp__Alternatives_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8047:1: ( ( rule__UnaryOp__Alternatives_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8047:1: ( ( rule__UnaryOp__Alternatives_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8048:1: ( rule__UnaryOp__Alternatives_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getAlternatives_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8049:1: ( rule__UnaryOp__Alternatives_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8049:2: rule__UnaryOp__Alternatives_0_0
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Alternatives_0_0_in_rule__UnaryOp__Group_0__0__Impl16653);
+ rule__UnaryOp__Alternatives_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getAlternatives_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8059:1: rule__UnaryOp__Group_0__1 : rule__UnaryOp__Group_0__1__Impl ;
+ public final void rule__UnaryOp__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8063:1: ( rule__UnaryOp__Group_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8064:2: rule__UnaryOp__Group_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Group_0__1__Impl_in_rule__UnaryOp__Group_0__116683);
+ rule__UnaryOp__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_0__1"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8070:1: rule__UnaryOp__Group_0__1__Impl : ( ruleExpression ) ;
+ public final void rule__UnaryOp__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8074:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8075:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8075:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8076:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__UnaryOp__Group_0__1__Impl16710);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8091:1: rule__UnaryOp__Group_1__0 : rule__UnaryOp__Group_1__0__Impl rule__UnaryOp__Group_1__1 ;
+ public final void rule__UnaryOp__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8095:1: ( rule__UnaryOp__Group_1__0__Impl rule__UnaryOp__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8096:2: rule__UnaryOp__Group_1__0__Impl rule__UnaryOp__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Group_1__0__Impl_in_rule__UnaryOp__Group_1__016743);
+ rule__UnaryOp__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__UnaryOp__Group_1__1_in_rule__UnaryOp__Group_1__016746);
+ rule__UnaryOp__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_1__0"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8103:1: rule__UnaryOp__Group_1__0__Impl : ( ( rule__UnaryOp__Alternatives_1_0 ) ) ;
+ public final void rule__UnaryOp__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8107:1: ( ( ( rule__UnaryOp__Alternatives_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8108:1: ( ( rule__UnaryOp__Alternatives_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8108:1: ( ( rule__UnaryOp__Alternatives_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8109:1: ( rule__UnaryOp__Alternatives_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getAlternatives_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8110:1: ( rule__UnaryOp__Alternatives_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8110:2: rule__UnaryOp__Alternatives_1_0
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Alternatives_1_0_in_rule__UnaryOp__Group_1__0__Impl16773);
+ rule__UnaryOp__Alternatives_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getAlternatives_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8120:1: rule__UnaryOp__Group_1__1 : rule__UnaryOp__Group_1__1__Impl ;
+ public final void rule__UnaryOp__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8124:1: ( rule__UnaryOp__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8125:2: rule__UnaryOp__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Group_1__1__Impl_in_rule__UnaryOp__Group_1__116803);
+ rule__UnaryOp__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_1__1"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8131:1: rule__UnaryOp__Group_1__1__Impl : ( ruleVariable ) ;
+ public final void rule__UnaryOp__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8135:1: ( ( ruleVariable ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8136:1: ( ruleVariable )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8136:1: ( ruleVariable )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8137:1: ruleVariable
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1());
+ }
+ pushFollow(FOLLOW_ruleVariable_in_rule__UnaryOp__Group_1__1__Impl16830);
+ ruleVariable();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8152:1: rule__UnaryOp__Group_2__0 : rule__UnaryOp__Group_2__0__Impl rule__UnaryOp__Group_2__1 ;
+ public final void rule__UnaryOp__Group_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8156:1: ( rule__UnaryOp__Group_2__0__Impl rule__UnaryOp__Group_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8157:2: rule__UnaryOp__Group_2__0__Impl rule__UnaryOp__Group_2__1
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Group_2__0__Impl_in_rule__UnaryOp__Group_2__016863);
+ rule__UnaryOp__Group_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__UnaryOp__Group_2__1_in_rule__UnaryOp__Group_2__016866);
+ rule__UnaryOp__Group_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_2__0"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8164:1: rule__UnaryOp__Group_2__0__Impl : ( ruleApplication ) ;
+ public final void rule__UnaryOp__Group_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8168:1: ( ( ruleApplication ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8169:1: ( ruleApplication )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8169:1: ( ruleApplication )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8170:1: ruleApplication
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_ruleApplication_in_rule__UnaryOp__Group_2__0__Impl16893);
+ ruleApplication();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_2__0__Impl"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8181:1: rule__UnaryOp__Group_2__1 : rule__UnaryOp__Group_2__1__Impl ;
+ public final void rule__UnaryOp__Group_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8185:1: ( rule__UnaryOp__Group_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8186:2: rule__UnaryOp__Group_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__UnaryOp__Group_2__1__Impl_in_rule__UnaryOp__Group_2__116922);
+ rule__UnaryOp__Group_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_2__1"
+
+
+ // $ANTLR start "rule__UnaryOp__Group_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8192:1: rule__UnaryOp__Group_2__1__Impl : ( ( RULE_QUESTION )? ) ;
+ public final void rule__UnaryOp__Group_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8196:1: ( ( ( RULE_QUESTION )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8197:1: ( ( RULE_QUESTION )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8197:1: ( ( RULE_QUESTION )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8198:1: ( RULE_QUESTION )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getUnaryOpAccess().getQUESTIONTerminalRuleCall_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8199:1: ( RULE_QUESTION )?
+ int alt71=2;
+ int LA71_0 = input.LA(1);
+
+ if ( (LA71_0==RULE_QUESTION) ) {
+ alt71=1;
+ }
+ switch (alt71) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8199:3: RULE_QUESTION
+ {
+ match(input,RULE_QUESTION,FOLLOW_RULE_QUESTION_in_rule__UnaryOp__Group_2__1__Impl16950); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getUnaryOpAccess().getQUESTIONTerminalRuleCall_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__UnaryOp__Group_2__1__Impl"
+
+
+ // $ANTLR start "rule__Application__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8213:1: rule__Application__Group_0__0 : rule__Application__Group_0__0__Impl rule__Application__Group_0__1 ;
+ public final void rule__Application__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8217:1: ( rule__Application__Group_0__0__Impl rule__Application__Group_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8218:2: rule__Application__Group_0__0__Impl rule__Application__Group_0__1
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0__0__Impl_in_rule__Application__Group_0__016985);
+ rule__Application__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Application__Group_0__1_in_rule__Application__Group_0__016988);
+ rule__Application__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0__0"
+
+
+ // $ANTLR start "rule__Application__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8225:1: rule__Application__Group_0__0__Impl : ( () ) ;
+ public final void rule__Application__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8229:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8230:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8230:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8231:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getSuperCallAction_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8232:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8234:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getSuperCallAction_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__Application__Group_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8244:1: rule__Application__Group_0__1 : rule__Application__Group_0__1__Impl ;
+ public final void rule__Application__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8248:1: ( rule__Application__Group_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8249:2: rule__Application__Group_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0__1__Impl_in_rule__Application__Group_0__117046);
+ rule__Application__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0__1"
+
+
+ // $ANTLR start "rule__Application__Group_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8255:1: rule__Application__Group_0__1__Impl : ( ( rule__Application__Group_0_1__0 ) ) ;
+ public final void rule__Application__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8259:1: ( ( ( rule__Application__Group_0_1__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8260:1: ( ( rule__Application__Group_0_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8260:1: ( ( rule__Application__Group_0_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8261:1: ( rule__Application__Group_0_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getGroup_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8262:1: ( rule__Application__Group_0_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8262:2: rule__Application__Group_0_1__0
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0_1__0_in_rule__Application__Group_0__1__Impl17073);
+ rule__Application__Group_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getGroup_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__Application__Group_0_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8276:1: rule__Application__Group_0_1__0 : rule__Application__Group_0_1__0__Impl rule__Application__Group_0_1__1 ;
+ public final void rule__Application__Group_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8280:1: ( rule__Application__Group_0_1__0__Impl rule__Application__Group_0_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8281:2: rule__Application__Group_0_1__0__Impl rule__Application__Group_0_1__1
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0_1__0__Impl_in_rule__Application__Group_0_1__017107);
+ rule__Application__Group_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Application__Group_0_1__1_in_rule__Application__Group_0_1__017110);
+ rule__Application__Group_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1__0"
+
+
+ // $ANTLR start "rule__Application__Group_0_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8288:1: rule__Application__Group_0_1__0__Impl : ( RULE_SUPER ) ;
+ public final void rule__Application__Group_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8292:1: ( ( RULE_SUPER ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8293:1: ( RULE_SUPER )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8293:1: ( RULE_SUPER )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8294:1: RULE_SUPER
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0());
+ }
+ match(input,RULE_SUPER,FOLLOW_RULE_SUPER_in_rule__Application__Group_0_1__0__Impl17137); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__Application__Group_0_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8305:1: rule__Application__Group_0_1__1 : rule__Application__Group_0_1__1__Impl ;
+ public final void rule__Application__Group_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8309:1: ( rule__Application__Group_0_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8310:2: rule__Application__Group_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0_1__1__Impl_in_rule__Application__Group_0_1__117166);
+ rule__Application__Group_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1__1"
+
+
+ // $ANTLR start "rule__Application__Group_0_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8316:1: rule__Application__Group_0_1__1__Impl : ( ( rule__Application__Group_0_1_1__0 )? ) ;
+ public final void rule__Application__Group_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8320:1: ( ( ( rule__Application__Group_0_1_1__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8321:1: ( ( rule__Application__Group_0_1_1__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8321:1: ( ( rule__Application__Group_0_1_1__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8322:1: ( rule__Application__Group_0_1_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getGroup_0_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8323:1: ( rule__Application__Group_0_1_1__0 )?
+ int alt72=2;
+ int LA72_0 = input.LA(1);
+
+ if ( (LA72_0==RULE_CALL_START) ) {
+ alt72=1;
+ }
+ switch (alt72) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8323:2: rule__Application__Group_0_1_1__0
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0_1_1__0_in_rule__Application__Group_0_1__1__Impl17193);
+ rule__Application__Group_0_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getGroup_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__Application__Group_0_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8337:1: rule__Application__Group_0_1_1__0 : rule__Application__Group_0_1_1__0__Impl rule__Application__Group_0_1_1__1 ;
+ public final void rule__Application__Group_0_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8341:1: ( rule__Application__Group_0_1_1__0__Impl rule__Application__Group_0_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8342:2: rule__Application__Group_0_1_1__0__Impl rule__Application__Group_0_1_1__1
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0_1_1__0__Impl_in_rule__Application__Group_0_1_1__017228);
+ rule__Application__Group_0_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Application__Group_0_1_1__1_in_rule__Application__Group_0_1_1__017231);
+ rule__Application__Group_0_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1_1__0"
+
+
+ // $ANTLR start "rule__Application__Group_0_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8349:1: rule__Application__Group_0_1_1__0__Impl : ( RULE_CALL_START ) ;
+ public final void rule__Application__Group_0_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8353:1: ( ( RULE_CALL_START ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8354:1: ( RULE_CALL_START )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8354:1: ( RULE_CALL_START )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8355:1: RULE_CALL_START
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0());
+ }
+ match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_rule__Application__Group_0_1_1__0__Impl17258); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__Application__Group_0_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8366:1: rule__Application__Group_0_1_1__1 : rule__Application__Group_0_1_1__1__Impl rule__Application__Group_0_1_1__2 ;
+ public final void rule__Application__Group_0_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8370:1: ( rule__Application__Group_0_1_1__1__Impl rule__Application__Group_0_1_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8371:2: rule__Application__Group_0_1_1__1__Impl rule__Application__Group_0_1_1__2
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0_1_1__1__Impl_in_rule__Application__Group_0_1_1__117287);
+ rule__Application__Group_0_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Application__Group_0_1_1__2_in_rule__Application__Group_0_1_1__117290);
+ rule__Application__Group_0_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1_1__1"
+
+
+ // $ANTLR start "rule__Application__Group_0_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8378:1: rule__Application__Group_0_1_1__1__Impl : ( ( rule__Application__ArgsAssignment_0_1_1_1 ) ) ;
+ public final void rule__Application__Group_0_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8382:1: ( ( ( rule__Application__ArgsAssignment_0_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8383:1: ( ( rule__Application__ArgsAssignment_0_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8383:1: ( ( rule__Application__ArgsAssignment_0_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8384:1: ( rule__Application__ArgsAssignment_0_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getArgsAssignment_0_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8385:1: ( rule__Application__ArgsAssignment_0_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8385:2: rule__Application__ArgsAssignment_0_1_1_1
+ {
+ pushFollow(FOLLOW_rule__Application__ArgsAssignment_0_1_1_1_in_rule__Application__Group_0_1_1__1__Impl17317);
+ rule__Application__ArgsAssignment_0_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getArgsAssignment_0_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__Application__Group_0_1_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8395:1: rule__Application__Group_0_1_1__2 : rule__Application__Group_0_1_1__2__Impl ;
+ public final void rule__Application__Group_0_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8399:1: ( rule__Application__Group_0_1_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8400:2: rule__Application__Group_0_1_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Application__Group_0_1_1__2__Impl_in_rule__Application__Group_0_1_1__217347);
+ rule__Application__Group_0_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1_1__2"
+
+
+ // $ANTLR start "rule__Application__Group_0_1_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8406:1: rule__Application__Group_0_1_1__2__Impl : ( RULE_CALL_END ) ;
+ public final void rule__Application__Group_0_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8410:1: ( ( RULE_CALL_END ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8411:1: ( RULE_CALL_END )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8411:1: ( RULE_CALL_END )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8412:1: RULE_CALL_END
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2());
+ }
+ match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_rule__Application__Group_0_1_1__2__Impl17374); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_0_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__Application__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8429:1: rule__Application__Group_1__0 : rule__Application__Group_1__0__Impl rule__Application__Group_1__1 ;
+ public final void rule__Application__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8433:1: ( rule__Application__Group_1__0__Impl rule__Application__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8434:2: rule__Application__Group_1__0__Impl rule__Application__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__Application__Group_1__0__Impl_in_rule__Application__Group_1__017409);
+ rule__Application__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Application__Group_1__1_in_rule__Application__Group_1__017412);
+ rule__Application__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_1__0"
+
+
+ // $ANTLR start "rule__Application__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8441:1: rule__Application__Group_1__0__Impl : ( ( rule__Application__ValueAssignment_1_0 ) ) ;
+ public final void rule__Application__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8445:1: ( ( ( rule__Application__ValueAssignment_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8446:1: ( ( rule__Application__ValueAssignment_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8446:1: ( ( rule__Application__ValueAssignment_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8447:1: ( rule__Application__ValueAssignment_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getValueAssignment_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8448:1: ( rule__Application__ValueAssignment_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8448:2: rule__Application__ValueAssignment_1_0
+ {
+ pushFollow(FOLLOW_rule__Application__ValueAssignment_1_0_in_rule__Application__Group_1__0__Impl17439);
+ rule__Application__ValueAssignment_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getValueAssignment_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__Application__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8458:1: rule__Application__Group_1__1 : rule__Application__Group_1__1__Impl ;
+ public final void rule__Application__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8462:1: ( rule__Application__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8463:2: rule__Application__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Application__Group_1__1__Impl_in_rule__Application__Group_1__117469);
+ rule__Application__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_1__1"
+
+
+ // $ANTLR start "rule__Application__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8469:1: rule__Application__Group_1__1__Impl : ( ( rule__Application__FeaturesAssignment_1_1 )* ) ;
+ public final void rule__Application__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8473:1: ( ( ( rule__Application__FeaturesAssignment_1_1 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8474:1: ( ( rule__Application__FeaturesAssignment_1_1 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8474:1: ( ( rule__Application__FeaturesAssignment_1_1 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8475:1: ( rule__Application__FeaturesAssignment_1_1 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getFeaturesAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8476:1: ( rule__Application__FeaturesAssignment_1_1 )*
+ loop73:
+ do {
+ int alt73=2;
+ int LA73_0 = input.LA(1);
+
+ if ( ((LA73_0>=RULE_DOT && LA73_0<=RULE_DOUBLE_COLON)||LA73_0==RULE_CALL_START||(LA73_0>=RULE_FUNC_EXIST && LA73_0<=RULE_INDEX_START)) ) {
+ alt73=1;
+ }
+
+
+ switch (alt73) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8476:2: rule__Application__FeaturesAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__Application__FeaturesAssignment_1_1_in_rule__Application__Group_1__1__Impl17496);
+ rule__Application__FeaturesAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop73;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getFeaturesAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8490:1: rule__FunctionCall__Group__0 : rule__FunctionCall__Group__0__Impl rule__FunctionCall__Group__1 ;
+ public final void rule__FunctionCall__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8494:1: ( rule__FunctionCall__Group__0__Impl rule__FunctionCall__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8495:2: rule__FunctionCall__Group__0__Impl rule__FunctionCall__Group__1
+ {
+ pushFollow(FOLLOW_rule__FunctionCall__Group__0__Impl_in_rule__FunctionCall__Group__017531);
+ rule__FunctionCall__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__FunctionCall__Group__1_in_rule__FunctionCall__Group__017534);
+ rule__FunctionCall__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__0"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8502:1: rule__FunctionCall__Group__0__Impl : ( () ) ;
+ public final void rule__FunctionCall__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8506:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8507:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8507:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8508:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFunctionCallAccess().getFunctionCallAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8509:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8511:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFunctionCallAccess().getFunctionCallAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__0__Impl"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8521:1: rule__FunctionCall__Group__1 : rule__FunctionCall__Group__1__Impl rule__FunctionCall__Group__2 ;
+ public final void rule__FunctionCall__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8525:1: ( rule__FunctionCall__Group__1__Impl rule__FunctionCall__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8526:2: rule__FunctionCall__Group__1__Impl rule__FunctionCall__Group__2
+ {
+ pushFollow(FOLLOW_rule__FunctionCall__Group__1__Impl_in_rule__FunctionCall__Group__117592);
+ rule__FunctionCall__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__FunctionCall__Group__2_in_rule__FunctionCall__Group__117595);
+ rule__FunctionCall__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__1"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8533:1: rule__FunctionCall__Group__1__Impl : ( ( RULE_FUNC_EXIST )? ) ;
+ public final void rule__FunctionCall__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8537:1: ( ( ( RULE_FUNC_EXIST )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8538:1: ( ( RULE_FUNC_EXIST )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8538:1: ( ( RULE_FUNC_EXIST )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8539:1: ( RULE_FUNC_EXIST )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFunctionCallAccess().getFUNC_EXISTTerminalRuleCall_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8540:1: ( RULE_FUNC_EXIST )?
+ int alt74=2;
+ int LA74_0 = input.LA(1);
+
+ if ( (LA74_0==RULE_FUNC_EXIST) ) {
+ alt74=1;
+ }
+ switch (alt74) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8540:3: RULE_FUNC_EXIST
+ {
+ match(input,RULE_FUNC_EXIST,FOLLOW_RULE_FUNC_EXIST_in_rule__FunctionCall__Group__1__Impl17623); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFunctionCallAccess().getFUNC_EXISTTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__1__Impl"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8550:1: rule__FunctionCall__Group__2 : rule__FunctionCall__Group__2__Impl rule__FunctionCall__Group__3 ;
+ public final void rule__FunctionCall__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8554:1: ( rule__FunctionCall__Group__2__Impl rule__FunctionCall__Group__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8555:2: rule__FunctionCall__Group__2__Impl rule__FunctionCall__Group__3
+ {
+ pushFollow(FOLLOW_rule__FunctionCall__Group__2__Impl_in_rule__FunctionCall__Group__217654);
+ rule__FunctionCall__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__FunctionCall__Group__3_in_rule__FunctionCall__Group__217657);
+ rule__FunctionCall__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__2"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8562:1: rule__FunctionCall__Group__2__Impl : ( RULE_CALL_START ) ;
+ public final void rule__FunctionCall__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8566:1: ( ( RULE_CALL_START ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8567:1: ( RULE_CALL_START )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8567:1: ( RULE_CALL_START )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8568:1: RULE_CALL_START
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2());
+ }
+ match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_rule__FunctionCall__Group__2__Impl17684); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__2__Impl"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8579:1: rule__FunctionCall__Group__3 : rule__FunctionCall__Group__3__Impl rule__FunctionCall__Group__4 ;
+ public final void rule__FunctionCall__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8583:1: ( rule__FunctionCall__Group__3__Impl rule__FunctionCall__Group__4 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8584:2: rule__FunctionCall__Group__3__Impl rule__FunctionCall__Group__4
+ {
+ pushFollow(FOLLOW_rule__FunctionCall__Group__3__Impl_in_rule__FunctionCall__Group__317713);
+ rule__FunctionCall__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__FunctionCall__Group__4_in_rule__FunctionCall__Group__317716);
+ rule__FunctionCall__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__3"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8591:1: rule__FunctionCall__Group__3__Impl : ( ( rule__FunctionCall__ArgsAssignment_3 ) ) ;
+ public final void rule__FunctionCall__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8595:1: ( ( ( rule__FunctionCall__ArgsAssignment_3 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8596:1: ( ( rule__FunctionCall__ArgsAssignment_3 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8596:1: ( ( rule__FunctionCall__ArgsAssignment_3 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8597:1: ( rule__FunctionCall__ArgsAssignment_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFunctionCallAccess().getArgsAssignment_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8598:1: ( rule__FunctionCall__ArgsAssignment_3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8598:2: rule__FunctionCall__ArgsAssignment_3
+ {
+ pushFollow(FOLLOW_rule__FunctionCall__ArgsAssignment_3_in_rule__FunctionCall__Group__3__Impl17743);
+ rule__FunctionCall__ArgsAssignment_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFunctionCallAccess().getArgsAssignment_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__3__Impl"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__4"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8608:1: rule__FunctionCall__Group__4 : rule__FunctionCall__Group__4__Impl ;
+ public final void rule__FunctionCall__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8612:1: ( rule__FunctionCall__Group__4__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8613:2: rule__FunctionCall__Group__4__Impl
+ {
+ pushFollow(FOLLOW_rule__FunctionCall__Group__4__Impl_in_rule__FunctionCall__Group__417773);
+ rule__FunctionCall__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__4"
+
+
+ // $ANTLR start "rule__FunctionCall__Group__4__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8619:1: rule__FunctionCall__Group__4__Impl : ( RULE_CALL_END ) ;
+ public final void rule__FunctionCall__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8623:1: ( ( RULE_CALL_END ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8624:1: ( RULE_CALL_END )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8624:1: ( RULE_CALL_END )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8625:1: RULE_CALL_END
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4());
+ }
+ match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_rule__FunctionCall__Group__4__Impl17800); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__Group__4__Impl"
+
+
+ // $ANTLR start "rule__ThisProperty__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8646:1: rule__ThisProperty__Group__0 : rule__ThisProperty__Group__0__Impl rule__ThisProperty__Group__1 ;
+ public final void rule__ThisProperty__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8650:1: ( rule__ThisProperty__Group__0__Impl rule__ThisProperty__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8651:2: rule__ThisProperty__Group__0__Impl rule__ThisProperty__Group__1
+ {
+ pushFollow(FOLLOW_rule__ThisProperty__Group__0__Impl_in_rule__ThisProperty__Group__017839);
+ rule__ThisProperty__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ThisProperty__Group__1_in_rule__ThisProperty__Group__017842);
+ rule__ThisProperty__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ThisProperty__Group__0"
+
+
+ // $ANTLR start "rule__ThisProperty__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8658:1: rule__ThisProperty__Group__0__Impl : ( RULE_AT_SIGIL ) ;
+ public final void rule__ThisProperty__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8662:1: ( ( RULE_AT_SIGIL ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8663:1: ( RULE_AT_SIGIL )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8663:1: ( RULE_AT_SIGIL )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8664:1: RULE_AT_SIGIL
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0());
+ }
+ match(input,RULE_AT_SIGIL,FOLLOW_RULE_AT_SIGIL_in_rule__ThisProperty__Group__0__Impl17869); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ThisProperty__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ThisProperty__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8675:1: rule__ThisProperty__Group__1 : rule__ThisProperty__Group__1__Impl ;
+ public final void rule__ThisProperty__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8679:1: ( rule__ThisProperty__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8680:2: rule__ThisProperty__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ThisProperty__Group__1__Impl_in_rule__ThisProperty__Group__117898);
+ rule__ThisProperty__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ThisProperty__Group__1"
+
+
+ // $ANTLR start "rule__ThisProperty__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8686:1: rule__ThisProperty__Group__1__Impl : ( ruleId ) ;
+ public final void rule__ThisProperty__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8690:1: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8691:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8691:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8692:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__ThisProperty__Group__1__Impl17925);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ThisProperty__Group__1__Impl"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8707:1: rule__NamedPropertyAccess__Group_0__0 : rule__NamedPropertyAccess__Group_0__0__Impl rule__NamedPropertyAccess__Group_0__1 ;
+ public final void rule__NamedPropertyAccess__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8711:1: ( rule__NamedPropertyAccess__Group_0__0__Impl rule__NamedPropertyAccess__Group_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8712:2: rule__NamedPropertyAccess__Group_0__0__Impl rule__NamedPropertyAccess__Group_0__1
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__Group_0__0__Impl_in_rule__NamedPropertyAccess__Group_0__017958);
+ rule__NamedPropertyAccess__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__Group_0__1_in_rule__NamedPropertyAccess__Group_0__017961);
+ rule__NamedPropertyAccess__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__Group_0__0"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8719:1: rule__NamedPropertyAccess__Group_0__0__Impl : ( ( rule__NamedPropertyAccess__AccessorAssignment_0_0 ) ) ;
+ public final void rule__NamedPropertyAccess__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8723:1: ( ( ( rule__NamedPropertyAccess__AccessorAssignment_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8724:1: ( ( rule__NamedPropertyAccess__AccessorAssignment_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8724:1: ( ( rule__NamedPropertyAccess__AccessorAssignment_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8725:1: ( rule__NamedPropertyAccess__AccessorAssignment_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8726:1: ( rule__NamedPropertyAccess__AccessorAssignment_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8726:2: rule__NamedPropertyAccess__AccessorAssignment_0_0
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__AccessorAssignment_0_0_in_rule__NamedPropertyAccess__Group_0__0__Impl17988);
+ rule__NamedPropertyAccess__AccessorAssignment_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__Group_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8736:1: rule__NamedPropertyAccess__Group_0__1 : rule__NamedPropertyAccess__Group_0__1__Impl ;
+ public final void rule__NamedPropertyAccess__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8740:1: ( rule__NamedPropertyAccess__Group_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8741:2: rule__NamedPropertyAccess__Group_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__Group_0__1__Impl_in_rule__NamedPropertyAccess__Group_0__118018);
+ rule__NamedPropertyAccess__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__Group_0__1"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__Group_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8747:1: rule__NamedPropertyAccess__Group_0__1__Impl : ( ( rule__NamedPropertyAccess__NameAssignment_0_1 ) ) ;
+ public final void rule__NamedPropertyAccess__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8751:1: ( ( ( rule__NamedPropertyAccess__NameAssignment_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8752:1: ( ( rule__NamedPropertyAccess__NameAssignment_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8752:1: ( ( rule__NamedPropertyAccess__NameAssignment_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8753:1: ( rule__NamedPropertyAccess__NameAssignment_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8754:1: ( rule__NamedPropertyAccess__NameAssignment_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8754:2: rule__NamedPropertyAccess__NameAssignment_0_1
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__NameAssignment_0_1_in_rule__NamedPropertyAccess__Group_0__1__Impl18045);
+ rule__NamedPropertyAccess__NameAssignment_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8768:1: rule__NamedPropertyAccess__Group_1__0 : rule__NamedPropertyAccess__Group_1__0__Impl rule__NamedPropertyAccess__Group_1__1 ;
+ public final void rule__NamedPropertyAccess__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8772:1: ( rule__NamedPropertyAccess__Group_1__0__Impl rule__NamedPropertyAccess__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8773:2: rule__NamedPropertyAccess__Group_1__0__Impl rule__NamedPropertyAccess__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__Group_1__0__Impl_in_rule__NamedPropertyAccess__Group_1__018079);
+ rule__NamedPropertyAccess__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__Group_1__1_in_rule__NamedPropertyAccess__Group_1__018082);
+ rule__NamedPropertyAccess__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__Group_1__0"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8780:1: rule__NamedPropertyAccess__Group_1__0__Impl : ( ( rule__NamedPropertyAccess__AccessorAssignment_1_0 ) ) ;
+ public final void rule__NamedPropertyAccess__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8784:1: ( ( ( rule__NamedPropertyAccess__AccessorAssignment_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8785:1: ( ( rule__NamedPropertyAccess__AccessorAssignment_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8785:1: ( ( rule__NamedPropertyAccess__AccessorAssignment_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8786:1: ( rule__NamedPropertyAccess__AccessorAssignment_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8787:1: ( rule__NamedPropertyAccess__AccessorAssignment_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8787:2: rule__NamedPropertyAccess__AccessorAssignment_1_0
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__AccessorAssignment_1_0_in_rule__NamedPropertyAccess__Group_1__0__Impl18109);
+ rule__NamedPropertyAccess__AccessorAssignment_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8797:1: rule__NamedPropertyAccess__Group_1__1 : rule__NamedPropertyAccess__Group_1__1__Impl ;
+ public final void rule__NamedPropertyAccess__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8801:1: ( rule__NamedPropertyAccess__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8802:2: rule__NamedPropertyAccess__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__Group_1__1__Impl_in_rule__NamedPropertyAccess__Group_1__118139);
+ rule__NamedPropertyAccess__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__Group_1__1"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8808:1: rule__NamedPropertyAccess__Group_1__1__Impl : ( ( rule__NamedPropertyAccess__NameAssignment_1_1 )? ) ;
+ public final void rule__NamedPropertyAccess__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8812:1: ( ( ( rule__NamedPropertyAccess__NameAssignment_1_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8813:1: ( ( rule__NamedPropertyAccess__NameAssignment_1_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8813:1: ( ( rule__NamedPropertyAccess__NameAssignment_1_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8814:1: ( rule__NamedPropertyAccess__NameAssignment_1_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8815:1: ( rule__NamedPropertyAccess__NameAssignment_1_1 )?
+ int alt75=2;
+ int LA75_0 = input.LA(1);
+
+ if ( (LA75_0==RULE_IDENTIFIER) ) {
+ alt75=1;
+ }
+ switch (alt75) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8815:2: rule__NamedPropertyAccess__NameAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__NameAssignment_1_1_in_rule__NamedPropertyAccess__Group_1__1__Impl18166);
+ rule__NamedPropertyAccess__NameAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__IndexedPropertyAccess__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8829:1: rule__IndexedPropertyAccess__Group__0 : rule__IndexedPropertyAccess__Group__0__Impl rule__IndexedPropertyAccess__Group__1 ;
+ public final void rule__IndexedPropertyAccess__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8833:1: ( rule__IndexedPropertyAccess__Group__0__Impl rule__IndexedPropertyAccess__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8834:2: rule__IndexedPropertyAccess__Group__0__Impl rule__IndexedPropertyAccess__Group__1
+ {
+ pushFollow(FOLLOW_rule__IndexedPropertyAccess__Group__0__Impl_in_rule__IndexedPropertyAccess__Group__018201);
+ rule__IndexedPropertyAccess__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__IndexedPropertyAccess__Group__1_in_rule__IndexedPropertyAccess__Group__018204);
+ rule__IndexedPropertyAccess__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IndexedPropertyAccess__Group__0"
+
+
+ // $ANTLR start "rule__IndexedPropertyAccess__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8841:1: rule__IndexedPropertyAccess__Group__0__Impl : ( RULE_INDEX_START ) ;
+ public final void rule__IndexedPropertyAccess__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8845:1: ( ( RULE_INDEX_START ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8846:1: ( RULE_INDEX_START )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8846:1: ( RULE_INDEX_START )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8847:1: RULE_INDEX_START
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0());
+ }
+ match(input,RULE_INDEX_START,FOLLOW_RULE_INDEX_START_in_rule__IndexedPropertyAccess__Group__0__Impl18231); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IndexedPropertyAccess__Group__0__Impl"
+
+
+ // $ANTLR start "rule__IndexedPropertyAccess__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8858:1: rule__IndexedPropertyAccess__Group__1 : rule__IndexedPropertyAccess__Group__1__Impl rule__IndexedPropertyAccess__Group__2 ;
+ public final void rule__IndexedPropertyAccess__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8862:1: ( rule__IndexedPropertyAccess__Group__1__Impl rule__IndexedPropertyAccess__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8863:2: rule__IndexedPropertyAccess__Group__1__Impl rule__IndexedPropertyAccess__Group__2
+ {
+ pushFollow(FOLLOW_rule__IndexedPropertyAccess__Group__1__Impl_in_rule__IndexedPropertyAccess__Group__118260);
+ rule__IndexedPropertyAccess__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__IndexedPropertyAccess__Group__2_in_rule__IndexedPropertyAccess__Group__118263);
+ rule__IndexedPropertyAccess__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IndexedPropertyAccess__Group__1"
+
+
+ // $ANTLR start "rule__IndexedPropertyAccess__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8870:1: rule__IndexedPropertyAccess__Group__1__Impl : ( ( rule__IndexedPropertyAccess__IndexAssignment_1 ) ) ;
+ public final void rule__IndexedPropertyAccess__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8874:1: ( ( ( rule__IndexedPropertyAccess__IndexAssignment_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8875:1: ( ( rule__IndexedPropertyAccess__IndexAssignment_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8875:1: ( ( rule__IndexedPropertyAccess__IndexAssignment_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8876:1: ( rule__IndexedPropertyAccess__IndexAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexedPropertyAccessAccess().getIndexAssignment_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8877:1: ( rule__IndexedPropertyAccess__IndexAssignment_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8877:2: rule__IndexedPropertyAccess__IndexAssignment_1
+ {
+ pushFollow(FOLLOW_rule__IndexedPropertyAccess__IndexAssignment_1_in_rule__IndexedPropertyAccess__Group__1__Impl18290);
+ rule__IndexedPropertyAccess__IndexAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexedPropertyAccessAccess().getIndexAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IndexedPropertyAccess__Group__1__Impl"
+
+
+ // $ANTLR start "rule__IndexedPropertyAccess__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8887:1: rule__IndexedPropertyAccess__Group__2 : rule__IndexedPropertyAccess__Group__2__Impl ;
+ public final void rule__IndexedPropertyAccess__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8891:1: ( rule__IndexedPropertyAccess__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8892:2: rule__IndexedPropertyAccess__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__IndexedPropertyAccess__Group__2__Impl_in_rule__IndexedPropertyAccess__Group__218320);
+ rule__IndexedPropertyAccess__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IndexedPropertyAccess__Group__2"
+
+
+ // $ANTLR start "rule__IndexedPropertyAccess__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8898:1: rule__IndexedPropertyAccess__Group__2__Impl : ( RULE_INDEX_END ) ;
+ public final void rule__IndexedPropertyAccess__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8902:1: ( ( RULE_INDEX_END ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8903:1: ( RULE_INDEX_END )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8903:1: ( RULE_INDEX_END )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8904:1: RULE_INDEX_END
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2());
+ }
+ match(input,RULE_INDEX_END,FOLLOW_RULE_INDEX_END_in_rule__IndexedPropertyAccess__Group__2__Impl18347); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IndexedPropertyAccess__Group__2__Impl"
+
+
+ // $ANTLR start "rule__Index__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8921:1: rule__Index__Group_0__0 : rule__Index__Group_0__0__Impl rule__Index__Group_0__1 ;
+ public final void rule__Index__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8925:1: ( rule__Index__Group_0__0__Impl rule__Index__Group_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8926:2: rule__Index__Group_0__0__Impl rule__Index__Group_0__1
+ {
+ pushFollow(FOLLOW_rule__Index__Group_0__0__Impl_in_rule__Index__Group_0__018382);
+ rule__Index__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Index__Group_0__1_in_rule__Index__Group_0__018385);
+ rule__Index__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_0__0"
+
+
+ // $ANTLR start "rule__Index__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8933:1: rule__Index__Group_0__0__Impl : ( ( rule__Index__DotsAssignment_0_0 ) ) ;
+ public final void rule__Index__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8937:1: ( ( ( rule__Index__DotsAssignment_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8938:1: ( ( rule__Index__DotsAssignment_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8938:1: ( ( rule__Index__DotsAssignment_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8939:1: ( rule__Index__DotsAssignment_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getDotsAssignment_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8940:1: ( rule__Index__DotsAssignment_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8940:2: rule__Index__DotsAssignment_0_0
+ {
+ pushFollow(FOLLOW_rule__Index__DotsAssignment_0_0_in_rule__Index__Group_0__0__Impl18412);
+ rule__Index__DotsAssignment_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getDotsAssignment_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__Index__Group_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8950:1: rule__Index__Group_0__1 : rule__Index__Group_0__1__Impl ;
+ public final void rule__Index__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8954:1: ( rule__Index__Group_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8955:2: rule__Index__Group_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Index__Group_0__1__Impl_in_rule__Index__Group_0__118442);
+ rule__Index__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_0__1"
+
+
+ // $ANTLR start "rule__Index__Group_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8961:1: rule__Index__Group_0__1__Impl : ( ( rule__Index__EndAssignment_0_1 ) ) ;
+ public final void rule__Index__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8965:1: ( ( ( rule__Index__EndAssignment_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8966:1: ( ( rule__Index__EndAssignment_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8966:1: ( ( rule__Index__EndAssignment_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8967:1: ( rule__Index__EndAssignment_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getEndAssignment_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8968:1: ( rule__Index__EndAssignment_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8968:2: rule__Index__EndAssignment_0_1
+ {
+ pushFollow(FOLLOW_rule__Index__EndAssignment_0_1_in_rule__Index__Group_0__1__Impl18469);
+ rule__Index__EndAssignment_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getEndAssignment_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__Index__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8982:1: rule__Index__Group_1__0 : rule__Index__Group_1__0__Impl rule__Index__Group_1__1 ;
+ public final void rule__Index__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8986:1: ( rule__Index__Group_1__0__Impl rule__Index__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8987:2: rule__Index__Group_1__0__Impl rule__Index__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__Index__Group_1__0__Impl_in_rule__Index__Group_1__018503);
+ rule__Index__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Index__Group_1__1_in_rule__Index__Group_1__018506);
+ rule__Index__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1__0"
+
+
+ // $ANTLR start "rule__Index__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8994:1: rule__Index__Group_1__0__Impl : ( ( rule__Index__Group_1_0__0 ) ) ;
+ public final void rule__Index__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8998:1: ( ( ( rule__Index__Group_1_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8999:1: ( ( rule__Index__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:8999:1: ( ( rule__Index__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9000:1: ( rule__Index__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9001:1: ( rule__Index__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9001:2: rule__Index__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__Index__Group_1_0__0_in_rule__Index__Group_1__0__Impl18533);
+ rule__Index__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__Index__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9011:1: rule__Index__Group_1__1 : rule__Index__Group_1__1__Impl ;
+ public final void rule__Index__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9015:1: ( rule__Index__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9016:2: rule__Index__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Index__Group_1__1__Impl_in_rule__Index__Group_1__118563);
+ rule__Index__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1__1"
+
+
+ // $ANTLR start "rule__Index__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9022:1: rule__Index__Group_1__1__Impl : ( ( rule__Index__EndAssignment_1_1 )? ) ;
+ public final void rule__Index__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9026:1: ( ( ( rule__Index__EndAssignment_1_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9027:1: ( ( rule__Index__EndAssignment_1_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9027:1: ( ( rule__Index__EndAssignment_1_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9028:1: ( rule__Index__EndAssignment_1_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getEndAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9029:1: ( rule__Index__EndAssignment_1_1 )?
+ int alt76=2;
+ int LA76_0 = input.LA(1);
+
+ if ( ((LA76_0>=RULE_PLUS && LA76_0<=RULE_MINUS_MINUS)||(LA76_0>=RULE_AT_SIGIL && LA76_0<=RULE_BOUND_FUNC_ARROW)||LA76_0==RULE_PARAM_START||(LA76_0>=RULE_FOR && LA76_0<=RULE_WHILE)||LA76_0==RULE_UNTIL||LA76_0==RULE_LBRACKET||LA76_0==RULE_SUPER||(LA76_0>=RULE_THIS && LA76_0<=RULE_TRY)||LA76_0==RULE_SWITCH||LA76_0==RULE_LCURLY||(LA76_0>=RULE_NUMBER && LA76_0<=RULE_REGEX)||LA76_0==RULE_LPAREN||(LA76_0>=RULE_IF && LA76_0<=RULE_IDENTIFIER)) ) {
+ alt76=1;
+ }
+ switch (alt76) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9029:2: rule__Index__EndAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__Index__EndAssignment_1_1_in_rule__Index__Group_1__1__Impl18590);
+ rule__Index__EndAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getEndAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__Index__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9043:1: rule__Index__Group_1_0__0 : rule__Index__Group_1_0__0__Impl ;
+ public final void rule__Index__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9047:1: ( rule__Index__Group_1_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9048:2: rule__Index__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__Index__Group_1_0__0__Impl_in_rule__Index__Group_1_0__018625);
+ rule__Index__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1_0__0"
+
+
+ // $ANTLR start "rule__Index__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9054:1: rule__Index__Group_1_0__0__Impl : ( ( rule__Index__Group_1_0_0__0 ) ) ;
+ public final void rule__Index__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9058:1: ( ( ( rule__Index__Group_1_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9059:1: ( ( rule__Index__Group_1_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9059:1: ( ( rule__Index__Group_1_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9060:1: ( rule__Index__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getGroup_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9061:1: ( rule__Index__Group_1_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9061:2: rule__Index__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_rule__Index__Group_1_0_0__0_in_rule__Index__Group_1_0__0__Impl18652);
+ rule__Index__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__Index__Group_1_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9073:1: rule__Index__Group_1_0_0__0 : rule__Index__Group_1_0_0__0__Impl rule__Index__Group_1_0_0__1 ;
+ public final void rule__Index__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9077:1: ( rule__Index__Group_1_0_0__0__Impl rule__Index__Group_1_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9078:2: rule__Index__Group_1_0_0__0__Impl rule__Index__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_rule__Index__Group_1_0_0__0__Impl_in_rule__Index__Group_1_0_0__018684);
+ rule__Index__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Index__Group_1_0_0__1_in_rule__Index__Group_1_0_0__018687);
+ rule__Index__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__Index__Group_1_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9085:1: rule__Index__Group_1_0_0__0__Impl : ( ( rule__Index__StartAssignment_1_0_0_0 ) ) ;
+ public final void rule__Index__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9089:1: ( ( ( rule__Index__StartAssignment_1_0_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9090:1: ( ( rule__Index__StartAssignment_1_0_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9090:1: ( ( rule__Index__StartAssignment_1_0_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9091:1: ( rule__Index__StartAssignment_1_0_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getStartAssignment_1_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9092:1: ( rule__Index__StartAssignment_1_0_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9092:2: rule__Index__StartAssignment_1_0_0_0
+ {
+ pushFollow(FOLLOW_rule__Index__StartAssignment_1_0_0_0_in_rule__Index__Group_1_0_0__0__Impl18714);
+ rule__Index__StartAssignment_1_0_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getStartAssignment_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__Index__Group_1_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9102:1: rule__Index__Group_1_0_0__1 : rule__Index__Group_1_0_0__1__Impl ;
+ public final void rule__Index__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9106:1: ( rule__Index__Group_1_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9107:2: rule__Index__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Index__Group_1_0_0__1__Impl_in_rule__Index__Group_1_0_0__118744);
+ rule__Index__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__Index__Group_1_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9113:1: rule__Index__Group_1_0_0__1__Impl : ( ( rule__Index__DotsAssignment_1_0_0_1 ) ) ;
+ public final void rule__Index__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9117:1: ( ( ( rule__Index__DotsAssignment_1_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9118:1: ( ( rule__Index__DotsAssignment_1_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9118:1: ( ( rule__Index__DotsAssignment_1_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9119:1: ( rule__Index__DotsAssignment_1_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getDotsAssignment_1_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9120:1: ( rule__Index__DotsAssignment_1_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9120:2: rule__Index__DotsAssignment_1_0_0_1
+ {
+ pushFollow(FOLLOW_rule__Index__DotsAssignment_1_0_0_1_in_rule__Index__Group_1_0_0__1__Impl18771);
+ rule__Index__DotsAssignment_1_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getDotsAssignment_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_8__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9134:1: rule__PrimaryExpression__Group_8__0 : rule__PrimaryExpression__Group_8__0__Impl rule__PrimaryExpression__Group_8__1 ;
+ public final void rule__PrimaryExpression__Group_8__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9138:1: ( rule__PrimaryExpression__Group_8__0__Impl rule__PrimaryExpression__Group_8__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9139:2: rule__PrimaryExpression__Group_8__0__Impl rule__PrimaryExpression__Group_8__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_8__0__Impl_in_rule__PrimaryExpression__Group_8__018805);
+ rule__PrimaryExpression__Group_8__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_8__1_in_rule__PrimaryExpression__Group_8__018808);
+ rule__PrimaryExpression__Group_8__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_8__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_8__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9146:1: rule__PrimaryExpression__Group_8__0__Impl : ( () ) ;
+ public final void rule__PrimaryExpression__Group_8__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9150:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9151:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9151:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9152:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9153:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9155:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_8__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_8__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9165:1: rule__PrimaryExpression__Group_8__1 : rule__PrimaryExpression__Group_8__1__Impl ;
+ public final void rule__PrimaryExpression__Group_8__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9169:1: ( rule__PrimaryExpression__Group_8__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9170:2: rule__PrimaryExpression__Group_8__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_8__1__Impl_in_rule__PrimaryExpression__Group_8__118866);
+ rule__PrimaryExpression__Group_8__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_8__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_8__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9176:1: rule__PrimaryExpression__Group_8__1__Impl : ( RULE_THIS ) ;
+ public final void rule__PrimaryExpression__Group_8__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9180:1: ( ( RULE_THIS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9181:1: ( RULE_THIS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9181:1: ( RULE_THIS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9182:1: RULE_THIS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1());
+ }
+ match(input,RULE_THIS,FOLLOW_RULE_THIS_in_rule__PrimaryExpression__Group_8__1__Impl18893); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_8__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9197:1: rule__PrimaryExpression__Group_9__0 : rule__PrimaryExpression__Group_9__0__Impl rule__PrimaryExpression__Group_9__1 ;
+ public final void rule__PrimaryExpression__Group_9__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9201:1: ( rule__PrimaryExpression__Group_9__0__Impl rule__PrimaryExpression__Group_9__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9202:2: rule__PrimaryExpression__Group_9__0__Impl rule__PrimaryExpression__Group_9__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9__0__Impl_in_rule__PrimaryExpression__Group_9__018926);
+ rule__PrimaryExpression__Group_9__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9__1_in_rule__PrimaryExpression__Group_9__018929);
+ rule__PrimaryExpression__Group_9__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9209:1: rule__PrimaryExpression__Group_9__0__Impl : ( () ) ;
+ public final void rule__PrimaryExpression__Group_9__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9213:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9214:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9214:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9215:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getForAction_9_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9216:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9218:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getForAction_9_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9228:1: rule__PrimaryExpression__Group_9__1 : rule__PrimaryExpression__Group_9__1__Impl ;
+ public final void rule__PrimaryExpression__Group_9__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9232:1: ( rule__PrimaryExpression__Group_9__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9233:2: rule__PrimaryExpression__Group_9__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9__1__Impl_in_rule__PrimaryExpression__Group_9__118987);
+ rule__PrimaryExpression__Group_9__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9239:1: rule__PrimaryExpression__Group_9__1__Impl : ( ( rule__PrimaryExpression__Group_9_1__0 ) ) ;
+ public final void rule__PrimaryExpression__Group_9__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9243:1: ( ( ( rule__PrimaryExpression__Group_9_1__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9244:1: ( ( rule__PrimaryExpression__Group_9_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9244:1: ( ( rule__PrimaryExpression__Group_9_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9245:1: ( rule__PrimaryExpression__Group_9_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_9_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9246:1: ( rule__PrimaryExpression__Group_9_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9246:2: rule__PrimaryExpression__Group_9_1__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9_1__0_in_rule__PrimaryExpression__Group_9__1__Impl19014);
+ rule__PrimaryExpression__Group_9_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_9_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9260:1: rule__PrimaryExpression__Group_9_1__0 : rule__PrimaryExpression__Group_9_1__0__Impl rule__PrimaryExpression__Group_9_1__1 ;
+ public final void rule__PrimaryExpression__Group_9_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9264:1: ( rule__PrimaryExpression__Group_9_1__0__Impl rule__PrimaryExpression__Group_9_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9265:2: rule__PrimaryExpression__Group_9_1__0__Impl rule__PrimaryExpression__Group_9_1__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9_1__0__Impl_in_rule__PrimaryExpression__Group_9_1__019048);
+ rule__PrimaryExpression__Group_9_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9_1__1_in_rule__PrimaryExpression__Group_9_1__019051);
+ rule__PrimaryExpression__Group_9_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9_1__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9272:1: rule__PrimaryExpression__Group_9_1__0__Impl : ( RULE_FOR ) ;
+ public final void rule__PrimaryExpression__Group_9_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9276:1: ( ( RULE_FOR ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9277:1: ( RULE_FOR )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9277:1: ( RULE_FOR )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9278:1: RULE_FOR
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0());
+ }
+ match(input,RULE_FOR,FOLLOW_RULE_FOR_in_rule__PrimaryExpression__Group_9_1__0__Impl19078); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9_1__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9289:1: rule__PrimaryExpression__Group_9_1__1 : rule__PrimaryExpression__Group_9_1__1__Impl rule__PrimaryExpression__Group_9_1__2 ;
+ public final void rule__PrimaryExpression__Group_9_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9293:1: ( rule__PrimaryExpression__Group_9_1__1__Impl rule__PrimaryExpression__Group_9_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9294:2: rule__PrimaryExpression__Group_9_1__1__Impl rule__PrimaryExpression__Group_9_1__2
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9_1__1__Impl_in_rule__PrimaryExpression__Group_9_1__119107);
+ rule__PrimaryExpression__Group_9_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9_1__2_in_rule__PrimaryExpression__Group_9_1__119110);
+ rule__PrimaryExpression__Group_9_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9_1__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9301:1: rule__PrimaryExpression__Group_9_1__1__Impl : ( ( rule__PrimaryExpression__LoopAssignment_9_1_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_9_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9305:1: ( ( ( rule__PrimaryExpression__LoopAssignment_9_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9306:1: ( ( rule__PrimaryExpression__LoopAssignment_9_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9306:1: ( ( rule__PrimaryExpression__LoopAssignment_9_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9307:1: ( rule__PrimaryExpression__LoopAssignment_9_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_9_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9308:1: ( rule__PrimaryExpression__LoopAssignment_9_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9308:2: rule__PrimaryExpression__LoopAssignment_9_1_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__LoopAssignment_9_1_1_in_rule__PrimaryExpression__Group_9_1__1__Impl19137);
+ rule__PrimaryExpression__LoopAssignment_9_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_9_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9_1__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9318:1: rule__PrimaryExpression__Group_9_1__2 : rule__PrimaryExpression__Group_9_1__2__Impl ;
+ public final void rule__PrimaryExpression__Group_9_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9322:1: ( rule__PrimaryExpression__Group_9_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9323:2: rule__PrimaryExpression__Group_9_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_9_1__2__Impl_in_rule__PrimaryExpression__Group_9_1__219167);
+ rule__PrimaryExpression__Group_9_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9_1__2"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_9_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9329:1: rule__PrimaryExpression__Group_9_1__2__Impl : ( ( rule__PrimaryExpression__BodyAssignment_9_1_2 ) ) ;
+ public final void rule__PrimaryExpression__Group_9_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9333:1: ( ( ( rule__PrimaryExpression__BodyAssignment_9_1_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9334:1: ( ( rule__PrimaryExpression__BodyAssignment_9_1_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9334:1: ( ( rule__PrimaryExpression__BodyAssignment_9_1_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9335:1: ( rule__PrimaryExpression__BodyAssignment_9_1_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_9_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9336:1: ( rule__PrimaryExpression__BodyAssignment_9_1_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9336:2: rule__PrimaryExpression__BodyAssignment_9_1_2
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__BodyAssignment_9_1_2_in_rule__PrimaryExpression__Group_9_1__2__Impl19194);
+ rule__PrimaryExpression__BodyAssignment_9_1_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_9_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_9_1__2__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9352:1: rule__PrimaryExpression__Group_10__0 : rule__PrimaryExpression__Group_10__0__Impl rule__PrimaryExpression__Group_10__1 ;
+ public final void rule__PrimaryExpression__Group_10__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9356:1: ( rule__PrimaryExpression__Group_10__0__Impl rule__PrimaryExpression__Group_10__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9357:2: rule__PrimaryExpression__Group_10__0__Impl rule__PrimaryExpression__Group_10__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10__0__Impl_in_rule__PrimaryExpression__Group_10__019230);
+ rule__PrimaryExpression__Group_10__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10__1_in_rule__PrimaryExpression__Group_10__019233);
+ rule__PrimaryExpression__Group_10__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9364:1: rule__PrimaryExpression__Group_10__0__Impl : ( () ) ;
+ public final void rule__PrimaryExpression__Group_10__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9368:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9369:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9369:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9370:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9371:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9373:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9383:1: rule__PrimaryExpression__Group_10__1 : rule__PrimaryExpression__Group_10__1__Impl ;
+ public final void rule__PrimaryExpression__Group_10__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9387:1: ( rule__PrimaryExpression__Group_10__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9388:2: rule__PrimaryExpression__Group_10__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10__1__Impl_in_rule__PrimaryExpression__Group_10__119291);
+ rule__PrimaryExpression__Group_10__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9394:1: rule__PrimaryExpression__Group_10__1__Impl : ( ( rule__PrimaryExpression__Group_10_1__0 ) ) ;
+ public final void rule__PrimaryExpression__Group_10__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9398:1: ( ( ( rule__PrimaryExpression__Group_10_1__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9399:1: ( ( rule__PrimaryExpression__Group_10_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9399:1: ( ( rule__PrimaryExpression__Group_10_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9400:1: ( rule__PrimaryExpression__Group_10_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9401:1: ( rule__PrimaryExpression__Group_10_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9401:2: rule__PrimaryExpression__Group_10_1__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1__0_in_rule__PrimaryExpression__Group_10__1__Impl19318);
+ rule__PrimaryExpression__Group_10_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9415:1: rule__PrimaryExpression__Group_10_1__0 : rule__PrimaryExpression__Group_10_1__0__Impl rule__PrimaryExpression__Group_10_1__1 ;
+ public final void rule__PrimaryExpression__Group_10_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9419:1: ( rule__PrimaryExpression__Group_10_1__0__Impl rule__PrimaryExpression__Group_10_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9420:2: rule__PrimaryExpression__Group_10_1__0__Impl rule__PrimaryExpression__Group_10_1__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1__0__Impl_in_rule__PrimaryExpression__Group_10_1__019352);
+ rule__PrimaryExpression__Group_10_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1__1_in_rule__PrimaryExpression__Group_10_1__019355);
+ rule__PrimaryExpression__Group_10_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9427:1: rule__PrimaryExpression__Group_10_1__0__Impl : ( RULE_WHILE ) ;
+ public final void rule__PrimaryExpression__Group_10_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9431:1: ( ( RULE_WHILE ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9432:1: ( RULE_WHILE )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9432:1: ( RULE_WHILE )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9433:1: RULE_WHILE
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0());
+ }
+ match(input,RULE_WHILE,FOLLOW_RULE_WHILE_in_rule__PrimaryExpression__Group_10_1__0__Impl19382); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9444:1: rule__PrimaryExpression__Group_10_1__1 : rule__PrimaryExpression__Group_10_1__1__Impl rule__PrimaryExpression__Group_10_1__2 ;
+ public final void rule__PrimaryExpression__Group_10_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9448:1: ( rule__PrimaryExpression__Group_10_1__1__Impl rule__PrimaryExpression__Group_10_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9449:2: rule__PrimaryExpression__Group_10_1__1__Impl rule__PrimaryExpression__Group_10_1__2
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1__1__Impl_in_rule__PrimaryExpression__Group_10_1__119411);
+ rule__PrimaryExpression__Group_10_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1__2_in_rule__PrimaryExpression__Group_10_1__119414);
+ rule__PrimaryExpression__Group_10_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9456:1: rule__PrimaryExpression__Group_10_1__1__Impl : ( ( rule__PrimaryExpression__LoopAssignment_10_1_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_10_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9460:1: ( ( ( rule__PrimaryExpression__LoopAssignment_10_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9461:1: ( ( rule__PrimaryExpression__LoopAssignment_10_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9461:1: ( ( rule__PrimaryExpression__LoopAssignment_10_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9462:1: ( rule__PrimaryExpression__LoopAssignment_10_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_10_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9463:1: ( rule__PrimaryExpression__LoopAssignment_10_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9463:2: rule__PrimaryExpression__LoopAssignment_10_1_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__LoopAssignment_10_1_1_in_rule__PrimaryExpression__Group_10_1__1__Impl19441);
+ rule__PrimaryExpression__LoopAssignment_10_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_10_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9473:1: rule__PrimaryExpression__Group_10_1__2 : rule__PrimaryExpression__Group_10_1__2__Impl rule__PrimaryExpression__Group_10_1__3 ;
+ public final void rule__PrimaryExpression__Group_10_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9477:1: ( rule__PrimaryExpression__Group_10_1__2__Impl rule__PrimaryExpression__Group_10_1__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9478:2: rule__PrimaryExpression__Group_10_1__2__Impl rule__PrimaryExpression__Group_10_1__3
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1__2__Impl_in_rule__PrimaryExpression__Group_10_1__219471);
+ rule__PrimaryExpression__Group_10_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1__3_in_rule__PrimaryExpression__Group_10_1__219474);
+ rule__PrimaryExpression__Group_10_1__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1__2"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9485:1: rule__PrimaryExpression__Group_10_1__2__Impl : ( ( rule__PrimaryExpression__Group_10_1_2__0 )? ) ;
+ public final void rule__PrimaryExpression__Group_10_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9489:1: ( ( ( rule__PrimaryExpression__Group_10_1_2__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9490:1: ( ( rule__PrimaryExpression__Group_10_1_2__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9490:1: ( ( rule__PrimaryExpression__Group_10_1_2__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9491:1: ( rule__PrimaryExpression__Group_10_1_2__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9492:1: ( rule__PrimaryExpression__Group_10_1_2__0 )?
+ int alt77=2;
+ int LA77_0 = input.LA(1);
+
+ if ( (LA77_0==RULE_WHEN) ) {
+ alt77=1;
+ }
+ switch (alt77) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9492:2: rule__PrimaryExpression__Group_10_1_2__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1_2__0_in_rule__PrimaryExpression__Group_10_1__2__Impl19501);
+ rule__PrimaryExpression__Group_10_1_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_10_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1__2__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9502:1: rule__PrimaryExpression__Group_10_1__3 : rule__PrimaryExpression__Group_10_1__3__Impl ;
+ public final void rule__PrimaryExpression__Group_10_1__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9506:1: ( rule__PrimaryExpression__Group_10_1__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9507:2: rule__PrimaryExpression__Group_10_1__3__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1__3__Impl_in_rule__PrimaryExpression__Group_10_1__319532);
+ rule__PrimaryExpression__Group_10_1__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1__3"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9513:1: rule__PrimaryExpression__Group_10_1__3__Impl : ( ( rule__PrimaryExpression__BodyAssignment_10_1_3 ) ) ;
+ public final void rule__PrimaryExpression__Group_10_1__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9517:1: ( ( ( rule__PrimaryExpression__BodyAssignment_10_1_3 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9518:1: ( ( rule__PrimaryExpression__BodyAssignment_10_1_3 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9518:1: ( ( rule__PrimaryExpression__BodyAssignment_10_1_3 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9519:1: ( rule__PrimaryExpression__BodyAssignment_10_1_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_10_1_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9520:1: ( rule__PrimaryExpression__BodyAssignment_10_1_3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9520:2: rule__PrimaryExpression__BodyAssignment_10_1_3
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__BodyAssignment_10_1_3_in_rule__PrimaryExpression__Group_10_1__3__Impl19559);
+ rule__PrimaryExpression__BodyAssignment_10_1_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_10_1_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1__3__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9538:1: rule__PrimaryExpression__Group_10_1_2__0 : rule__PrimaryExpression__Group_10_1_2__0__Impl rule__PrimaryExpression__Group_10_1_2__1 ;
+ public final void rule__PrimaryExpression__Group_10_1_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9542:1: ( rule__PrimaryExpression__Group_10_1_2__0__Impl rule__PrimaryExpression__Group_10_1_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9543:2: rule__PrimaryExpression__Group_10_1_2__0__Impl rule__PrimaryExpression__Group_10_1_2__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1_2__0__Impl_in_rule__PrimaryExpression__Group_10_1_2__019597);
+ rule__PrimaryExpression__Group_10_1_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1_2__1_in_rule__PrimaryExpression__Group_10_1_2__019600);
+ rule__PrimaryExpression__Group_10_1_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1_2__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9550:1: rule__PrimaryExpression__Group_10_1_2__0__Impl : ( RULE_WHEN ) ;
+ public final void rule__PrimaryExpression__Group_10_1_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9554:1: ( ( RULE_WHEN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9555:1: ( RULE_WHEN )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9555:1: ( RULE_WHEN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9556:1: RULE_WHEN
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0());
+ }
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rule__PrimaryExpression__Group_10_1_2__0__Impl19627); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1_2__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9567:1: rule__PrimaryExpression__Group_10_1_2__1 : rule__PrimaryExpression__Group_10_1_2__1__Impl ;
+ public final void rule__PrimaryExpression__Group_10_1_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9571:1: ( rule__PrimaryExpression__Group_10_1_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9572:2: rule__PrimaryExpression__Group_10_1_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_10_1_2__1__Impl_in_rule__PrimaryExpression__Group_10_1_2__119656);
+ rule__PrimaryExpression__Group_10_1_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1_2__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_10_1_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9578:1: rule__PrimaryExpression__Group_10_1_2__1__Impl : ( ( rule__PrimaryExpression__WhenAssignment_10_1_2_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_10_1_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9582:1: ( ( ( rule__PrimaryExpression__WhenAssignment_10_1_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9583:1: ( ( rule__PrimaryExpression__WhenAssignment_10_1_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9583:1: ( ( rule__PrimaryExpression__WhenAssignment_10_1_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9584:1: ( rule__PrimaryExpression__WhenAssignment_10_1_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_10_1_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9585:1: ( rule__PrimaryExpression__WhenAssignment_10_1_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9585:2: rule__PrimaryExpression__WhenAssignment_10_1_2_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__WhenAssignment_10_1_2_1_in_rule__PrimaryExpression__Group_10_1_2__1__Impl19683);
+ rule__PrimaryExpression__WhenAssignment_10_1_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_10_1_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_10_1_2__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9599:1: rule__PrimaryExpression__Group_11__0 : rule__PrimaryExpression__Group_11__0__Impl rule__PrimaryExpression__Group_11__1 ;
+ public final void rule__PrimaryExpression__Group_11__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9603:1: ( rule__PrimaryExpression__Group_11__0__Impl rule__PrimaryExpression__Group_11__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9604:2: rule__PrimaryExpression__Group_11__0__Impl rule__PrimaryExpression__Group_11__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11__0__Impl_in_rule__PrimaryExpression__Group_11__019717);
+ rule__PrimaryExpression__Group_11__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11__1_in_rule__PrimaryExpression__Group_11__019720);
+ rule__PrimaryExpression__Group_11__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9611:1: rule__PrimaryExpression__Group_11__0__Impl : ( () ) ;
+ public final void rule__PrimaryExpression__Group_11__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9615:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9616:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9616:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9617:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9618:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9620:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9630:1: rule__PrimaryExpression__Group_11__1 : rule__PrimaryExpression__Group_11__1__Impl ;
+ public final void rule__PrimaryExpression__Group_11__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9634:1: ( rule__PrimaryExpression__Group_11__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9635:2: rule__PrimaryExpression__Group_11__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11__1__Impl_in_rule__PrimaryExpression__Group_11__119778);
+ rule__PrimaryExpression__Group_11__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9641:1: rule__PrimaryExpression__Group_11__1__Impl : ( ( rule__PrimaryExpression__Group_11_1__0 ) ) ;
+ public final void rule__PrimaryExpression__Group_11__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9645:1: ( ( ( rule__PrimaryExpression__Group_11_1__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9646:1: ( ( rule__PrimaryExpression__Group_11_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9646:1: ( ( rule__PrimaryExpression__Group_11_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9647:1: ( rule__PrimaryExpression__Group_11_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9648:1: ( rule__PrimaryExpression__Group_11_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9648:2: rule__PrimaryExpression__Group_11_1__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1__0_in_rule__PrimaryExpression__Group_11__1__Impl19805);
+ rule__PrimaryExpression__Group_11_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9662:1: rule__PrimaryExpression__Group_11_1__0 : rule__PrimaryExpression__Group_11_1__0__Impl rule__PrimaryExpression__Group_11_1__1 ;
+ public final void rule__PrimaryExpression__Group_11_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9666:1: ( rule__PrimaryExpression__Group_11_1__0__Impl rule__PrimaryExpression__Group_11_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9667:2: rule__PrimaryExpression__Group_11_1__0__Impl rule__PrimaryExpression__Group_11_1__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1__0__Impl_in_rule__PrimaryExpression__Group_11_1__019839);
+ rule__PrimaryExpression__Group_11_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1__1_in_rule__PrimaryExpression__Group_11_1__019842);
+ rule__PrimaryExpression__Group_11_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9674:1: rule__PrimaryExpression__Group_11_1__0__Impl : ( RULE_UNTIL ) ;
+ public final void rule__PrimaryExpression__Group_11_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9678:1: ( ( RULE_UNTIL ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9679:1: ( RULE_UNTIL )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9679:1: ( RULE_UNTIL )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9680:1: RULE_UNTIL
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0());
+ }
+ match(input,RULE_UNTIL,FOLLOW_RULE_UNTIL_in_rule__PrimaryExpression__Group_11_1__0__Impl19869); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9691:1: rule__PrimaryExpression__Group_11_1__1 : rule__PrimaryExpression__Group_11_1__1__Impl rule__PrimaryExpression__Group_11_1__2 ;
+ public final void rule__PrimaryExpression__Group_11_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9695:1: ( rule__PrimaryExpression__Group_11_1__1__Impl rule__PrimaryExpression__Group_11_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9696:2: rule__PrimaryExpression__Group_11_1__1__Impl rule__PrimaryExpression__Group_11_1__2
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1__1__Impl_in_rule__PrimaryExpression__Group_11_1__119898);
+ rule__PrimaryExpression__Group_11_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1__2_in_rule__PrimaryExpression__Group_11_1__119901);
+ rule__PrimaryExpression__Group_11_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9703:1: rule__PrimaryExpression__Group_11_1__1__Impl : ( ( rule__PrimaryExpression__LoopAssignment_11_1_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_11_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9707:1: ( ( ( rule__PrimaryExpression__LoopAssignment_11_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9708:1: ( ( rule__PrimaryExpression__LoopAssignment_11_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9708:1: ( ( rule__PrimaryExpression__LoopAssignment_11_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9709:1: ( rule__PrimaryExpression__LoopAssignment_11_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_11_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9710:1: ( rule__PrimaryExpression__LoopAssignment_11_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9710:2: rule__PrimaryExpression__LoopAssignment_11_1_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__LoopAssignment_11_1_1_in_rule__PrimaryExpression__Group_11_1__1__Impl19928);
+ rule__PrimaryExpression__LoopAssignment_11_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_11_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9720:1: rule__PrimaryExpression__Group_11_1__2 : rule__PrimaryExpression__Group_11_1__2__Impl rule__PrimaryExpression__Group_11_1__3 ;
+ public final void rule__PrimaryExpression__Group_11_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9724:1: ( rule__PrimaryExpression__Group_11_1__2__Impl rule__PrimaryExpression__Group_11_1__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9725:2: rule__PrimaryExpression__Group_11_1__2__Impl rule__PrimaryExpression__Group_11_1__3
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1__2__Impl_in_rule__PrimaryExpression__Group_11_1__219958);
+ rule__PrimaryExpression__Group_11_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1__3_in_rule__PrimaryExpression__Group_11_1__219961);
+ rule__PrimaryExpression__Group_11_1__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1__2"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9732:1: rule__PrimaryExpression__Group_11_1__2__Impl : ( ( rule__PrimaryExpression__Group_11_1_2__0 )? ) ;
+ public final void rule__PrimaryExpression__Group_11_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9736:1: ( ( ( rule__PrimaryExpression__Group_11_1_2__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9737:1: ( ( rule__PrimaryExpression__Group_11_1_2__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9737:1: ( ( rule__PrimaryExpression__Group_11_1_2__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9738:1: ( rule__PrimaryExpression__Group_11_1_2__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9739:1: ( rule__PrimaryExpression__Group_11_1_2__0 )?
+ int alt78=2;
+ int LA78_0 = input.LA(1);
+
+ if ( (LA78_0==RULE_WHEN) ) {
+ alt78=1;
+ }
+ switch (alt78) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9739:2: rule__PrimaryExpression__Group_11_1_2__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1_2__0_in_rule__PrimaryExpression__Group_11_1__2__Impl19988);
+ rule__PrimaryExpression__Group_11_1_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_11_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1__2__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9749:1: rule__PrimaryExpression__Group_11_1__3 : rule__PrimaryExpression__Group_11_1__3__Impl ;
+ public final void rule__PrimaryExpression__Group_11_1__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9753:1: ( rule__PrimaryExpression__Group_11_1__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9754:2: rule__PrimaryExpression__Group_11_1__3__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1__3__Impl_in_rule__PrimaryExpression__Group_11_1__320019);
+ rule__PrimaryExpression__Group_11_1__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1__3"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9760:1: rule__PrimaryExpression__Group_11_1__3__Impl : ( ( rule__PrimaryExpression__BodyAssignment_11_1_3 ) ) ;
+ public final void rule__PrimaryExpression__Group_11_1__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9764:1: ( ( ( rule__PrimaryExpression__BodyAssignment_11_1_3 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9765:1: ( ( rule__PrimaryExpression__BodyAssignment_11_1_3 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9765:1: ( ( rule__PrimaryExpression__BodyAssignment_11_1_3 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9766:1: ( rule__PrimaryExpression__BodyAssignment_11_1_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_11_1_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9767:1: ( rule__PrimaryExpression__BodyAssignment_11_1_3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9767:2: rule__PrimaryExpression__BodyAssignment_11_1_3
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__BodyAssignment_11_1_3_in_rule__PrimaryExpression__Group_11_1__3__Impl20046);
+ rule__PrimaryExpression__BodyAssignment_11_1_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_11_1_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1__3__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9785:1: rule__PrimaryExpression__Group_11_1_2__0 : rule__PrimaryExpression__Group_11_1_2__0__Impl rule__PrimaryExpression__Group_11_1_2__1 ;
+ public final void rule__PrimaryExpression__Group_11_1_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9789:1: ( rule__PrimaryExpression__Group_11_1_2__0__Impl rule__PrimaryExpression__Group_11_1_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9790:2: rule__PrimaryExpression__Group_11_1_2__0__Impl rule__PrimaryExpression__Group_11_1_2__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1_2__0__Impl_in_rule__PrimaryExpression__Group_11_1_2__020084);
+ rule__PrimaryExpression__Group_11_1_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1_2__1_in_rule__PrimaryExpression__Group_11_1_2__020087);
+ rule__PrimaryExpression__Group_11_1_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1_2__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9797:1: rule__PrimaryExpression__Group_11_1_2__0__Impl : ( RULE_WHEN ) ;
+ public final void rule__PrimaryExpression__Group_11_1_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9801:1: ( ( RULE_WHEN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9802:1: ( RULE_WHEN )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9802:1: ( RULE_WHEN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9803:1: RULE_WHEN
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0());
+ }
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rule__PrimaryExpression__Group_11_1_2__0__Impl20114); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1_2__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9814:1: rule__PrimaryExpression__Group_11_1_2__1 : rule__PrimaryExpression__Group_11_1_2__1__Impl ;
+ public final void rule__PrimaryExpression__Group_11_1_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9818:1: ( rule__PrimaryExpression__Group_11_1_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9819:2: rule__PrimaryExpression__Group_11_1_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_11_1_2__1__Impl_in_rule__PrimaryExpression__Group_11_1_2__120143);
+ rule__PrimaryExpression__Group_11_1_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1_2__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_11_1_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9825:1: rule__PrimaryExpression__Group_11_1_2__1__Impl : ( ( rule__PrimaryExpression__WhenAssignment_11_1_2_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_11_1_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9829:1: ( ( ( rule__PrimaryExpression__WhenAssignment_11_1_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9830:1: ( ( rule__PrimaryExpression__WhenAssignment_11_1_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9830:1: ( ( rule__PrimaryExpression__WhenAssignment_11_1_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9831:1: ( rule__PrimaryExpression__WhenAssignment_11_1_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_11_1_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9832:1: ( rule__PrimaryExpression__WhenAssignment_11_1_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9832:2: rule__PrimaryExpression__WhenAssignment_11_1_2_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__WhenAssignment_11_1_2_1_in_rule__PrimaryExpression__Group_11_1_2__1__Impl20170);
+ rule__PrimaryExpression__WhenAssignment_11_1_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_11_1_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_11_1_2__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_12__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9846:1: rule__PrimaryExpression__Group_12__0 : rule__PrimaryExpression__Group_12__0__Impl rule__PrimaryExpression__Group_12__1 ;
+ public final void rule__PrimaryExpression__Group_12__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9850:1: ( rule__PrimaryExpression__Group_12__0__Impl rule__PrimaryExpression__Group_12__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9851:2: rule__PrimaryExpression__Group_12__0__Impl rule__PrimaryExpression__Group_12__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_12__0__Impl_in_rule__PrimaryExpression__Group_12__020204);
+ rule__PrimaryExpression__Group_12__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_12__1_in_rule__PrimaryExpression__Group_12__020207);
+ rule__PrimaryExpression__Group_12__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_12__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_12__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9858:1: rule__PrimaryExpression__Group_12__0__Impl : ( () ) ;
+ public final void rule__PrimaryExpression__Group_12__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9862:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9863:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9863:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9864:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9865:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9867:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_12__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_12__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9877:1: rule__PrimaryExpression__Group_12__1 : rule__PrimaryExpression__Group_12__1__Impl ;
+ public final void rule__PrimaryExpression__Group_12__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9881:1: ( rule__PrimaryExpression__Group_12__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9882:2: rule__PrimaryExpression__Group_12__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_12__1__Impl_in_rule__PrimaryExpression__Group_12__120265);
+ rule__PrimaryExpression__Group_12__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_12__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_12__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9888:1: rule__PrimaryExpression__Group_12__1__Impl : ( ( rule__PrimaryExpression__Group_12_1__0 ) ) ;
+ public final void rule__PrimaryExpression__Group_12__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9892:1: ( ( ( rule__PrimaryExpression__Group_12_1__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9893:1: ( ( rule__PrimaryExpression__Group_12_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9893:1: ( ( rule__PrimaryExpression__Group_12_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9894:1: ( rule__PrimaryExpression__Group_12_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_12_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9895:1: ( rule__PrimaryExpression__Group_12_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9895:2: rule__PrimaryExpression__Group_12_1__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_12_1__0_in_rule__PrimaryExpression__Group_12__1__Impl20292);
+ rule__PrimaryExpression__Group_12_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_12_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_12__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_12_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9909:1: rule__PrimaryExpression__Group_12_1__0 : rule__PrimaryExpression__Group_12_1__0__Impl rule__PrimaryExpression__Group_12_1__1 ;
+ public final void rule__PrimaryExpression__Group_12_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9913:1: ( rule__PrimaryExpression__Group_12_1__0__Impl rule__PrimaryExpression__Group_12_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9914:2: rule__PrimaryExpression__Group_12_1__0__Impl rule__PrimaryExpression__Group_12_1__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_12_1__0__Impl_in_rule__PrimaryExpression__Group_12_1__020326);
+ rule__PrimaryExpression__Group_12_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_12_1__1_in_rule__PrimaryExpression__Group_12_1__020329);
+ rule__PrimaryExpression__Group_12_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_12_1__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_12_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9921:1: rule__PrimaryExpression__Group_12_1__0__Impl : ( RULE_LOOP ) ;
+ public final void rule__PrimaryExpression__Group_12_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9925:1: ( ( RULE_LOOP ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9926:1: ( RULE_LOOP )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9926:1: ( RULE_LOOP )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9927:1: RULE_LOOP
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0());
+ }
+ match(input,RULE_LOOP,FOLLOW_RULE_LOOP_in_rule__PrimaryExpression__Group_12_1__0__Impl20356); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_12_1__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_12_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9938:1: rule__PrimaryExpression__Group_12_1__1 : rule__PrimaryExpression__Group_12_1__1__Impl ;
+ public final void rule__PrimaryExpression__Group_12_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9942:1: ( rule__PrimaryExpression__Group_12_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9943:2: rule__PrimaryExpression__Group_12_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_12_1__1__Impl_in_rule__PrimaryExpression__Group_12_1__120385);
+ rule__PrimaryExpression__Group_12_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_12_1__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_12_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9949:1: rule__PrimaryExpression__Group_12_1__1__Impl : ( ( rule__PrimaryExpression__BodyAssignment_12_1_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_12_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9953:1: ( ( ( rule__PrimaryExpression__BodyAssignment_12_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9954:1: ( ( rule__PrimaryExpression__BodyAssignment_12_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9954:1: ( ( rule__PrimaryExpression__BodyAssignment_12_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9955:1: ( rule__PrimaryExpression__BodyAssignment_12_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_12_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9956:1: ( rule__PrimaryExpression__BodyAssignment_12_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9956:2: rule__PrimaryExpression__BodyAssignment_12_1_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__BodyAssignment_12_1_1_in_rule__PrimaryExpression__Group_12_1__1__Impl20412);
+ rule__PrimaryExpression__BodyAssignment_12_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_12_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_12_1__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9970:1: rule__PrimaryExpression__Group_13__0 : rule__PrimaryExpression__Group_13__0__Impl rule__PrimaryExpression__Group_13__1 ;
+ public final void rule__PrimaryExpression__Group_13__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9974:1: ( rule__PrimaryExpression__Group_13__0__Impl rule__PrimaryExpression__Group_13__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9975:2: rule__PrimaryExpression__Group_13__0__Impl rule__PrimaryExpression__Group_13__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13__0__Impl_in_rule__PrimaryExpression__Group_13__020446);
+ rule__PrimaryExpression__Group_13__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13__1_in_rule__PrimaryExpression__Group_13__020449);
+ rule__PrimaryExpression__Group_13__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9982:1: rule__PrimaryExpression__Group_13__0__Impl : ( () ) ;
+ public final void rule__PrimaryExpression__Group_13__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9986:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9987:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9987:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9988:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9989:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:9991:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10001:1: rule__PrimaryExpression__Group_13__1 : rule__PrimaryExpression__Group_13__1__Impl ;
+ public final void rule__PrimaryExpression__Group_13__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10005:1: ( rule__PrimaryExpression__Group_13__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10006:2: rule__PrimaryExpression__Group_13__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13__1__Impl_in_rule__PrimaryExpression__Group_13__120507);
+ rule__PrimaryExpression__Group_13__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10012:1: rule__PrimaryExpression__Group_13__1__Impl : ( ( rule__PrimaryExpression__Group_13_1__0 ) ) ;
+ public final void rule__PrimaryExpression__Group_13__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10016:1: ( ( ( rule__PrimaryExpression__Group_13_1__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10017:1: ( ( rule__PrimaryExpression__Group_13_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10017:1: ( ( rule__PrimaryExpression__Group_13_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10018:1: ( rule__PrimaryExpression__Group_13_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10019:1: ( rule__PrimaryExpression__Group_13_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10019:2: rule__PrimaryExpression__Group_13_1__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1__0_in_rule__PrimaryExpression__Group_13__1__Impl20534);
+ rule__PrimaryExpression__Group_13_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10033:1: rule__PrimaryExpression__Group_13_1__0 : rule__PrimaryExpression__Group_13_1__0__Impl rule__PrimaryExpression__Group_13_1__1 ;
+ public final void rule__PrimaryExpression__Group_13_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10037:1: ( rule__PrimaryExpression__Group_13_1__0__Impl rule__PrimaryExpression__Group_13_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10038:2: rule__PrimaryExpression__Group_13_1__0__Impl rule__PrimaryExpression__Group_13_1__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1__0__Impl_in_rule__PrimaryExpression__Group_13_1__020568);
+ rule__PrimaryExpression__Group_13_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1__1_in_rule__PrimaryExpression__Group_13_1__020571);
+ rule__PrimaryExpression__Group_13_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10045:1: rule__PrimaryExpression__Group_13_1__0__Impl : ( RULE_TRY ) ;
+ public final void rule__PrimaryExpression__Group_13_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10049:1: ( ( RULE_TRY ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10050:1: ( RULE_TRY )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10050:1: ( RULE_TRY )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10051:1: RULE_TRY
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0());
+ }
+ match(input,RULE_TRY,FOLLOW_RULE_TRY_in_rule__PrimaryExpression__Group_13_1__0__Impl20598); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10062:1: rule__PrimaryExpression__Group_13_1__1 : rule__PrimaryExpression__Group_13_1__1__Impl rule__PrimaryExpression__Group_13_1__2 ;
+ public final void rule__PrimaryExpression__Group_13_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10066:1: ( rule__PrimaryExpression__Group_13_1__1__Impl rule__PrimaryExpression__Group_13_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10067:2: rule__PrimaryExpression__Group_13_1__1__Impl rule__PrimaryExpression__Group_13_1__2
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1__1__Impl_in_rule__PrimaryExpression__Group_13_1__120627);
+ rule__PrimaryExpression__Group_13_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1__2_in_rule__PrimaryExpression__Group_13_1__120630);
+ rule__PrimaryExpression__Group_13_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10074:1: rule__PrimaryExpression__Group_13_1__1__Impl : ( ( rule__PrimaryExpression__BodyAssignment_13_1_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_13_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10078:1: ( ( ( rule__PrimaryExpression__BodyAssignment_13_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10079:1: ( ( rule__PrimaryExpression__BodyAssignment_13_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10079:1: ( ( rule__PrimaryExpression__BodyAssignment_13_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10080:1: ( rule__PrimaryExpression__BodyAssignment_13_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_13_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10081:1: ( rule__PrimaryExpression__BodyAssignment_13_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10081:2: rule__PrimaryExpression__BodyAssignment_13_1_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__BodyAssignment_13_1_1_in_rule__PrimaryExpression__Group_13_1__1__Impl20657);
+ rule__PrimaryExpression__BodyAssignment_13_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_13_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10091:1: rule__PrimaryExpression__Group_13_1__2 : rule__PrimaryExpression__Group_13_1__2__Impl ;
+ public final void rule__PrimaryExpression__Group_13_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10095:1: ( rule__PrimaryExpression__Group_13_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10096:2: rule__PrimaryExpression__Group_13_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1__2__Impl_in_rule__PrimaryExpression__Group_13_1__220687);
+ rule__PrimaryExpression__Group_13_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1__2"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10102:1: rule__PrimaryExpression__Group_13_1__2__Impl : ( ( rule__PrimaryExpression__Alternatives_13_1_2 )? ) ;
+ public final void rule__PrimaryExpression__Group_13_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10106:1: ( ( ( rule__PrimaryExpression__Alternatives_13_1_2 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10107:1: ( ( rule__PrimaryExpression__Alternatives_13_1_2 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10107:1: ( ( rule__PrimaryExpression__Alternatives_13_1_2 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10108:1: ( rule__PrimaryExpression__Alternatives_13_1_2 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getAlternatives_13_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10109:1: ( rule__PrimaryExpression__Alternatives_13_1_2 )?
+ int alt79=2;
+ int LA79_0 = input.LA(1);
+
+ if ( ((LA79_0>=RULE_CATCH && LA79_0<=RULE_FINALLY)) ) {
+ alt79=1;
+ }
+ switch (alt79) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10109:2: rule__PrimaryExpression__Alternatives_13_1_2
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Alternatives_13_1_2_in_rule__PrimaryExpression__Group_13_1__2__Impl20714);
+ rule__PrimaryExpression__Alternatives_13_1_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getAlternatives_13_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1__2__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10125:1: rule__PrimaryExpression__Group_13_1_2_0__0 : rule__PrimaryExpression__Group_13_1_2_0__0__Impl rule__PrimaryExpression__Group_13_1_2_0__1 ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10129:1: ( rule__PrimaryExpression__Group_13_1_2_0__0__Impl rule__PrimaryExpression__Group_13_1_2_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10130:2: rule__PrimaryExpression__Group_13_1_2_0__0__Impl rule__PrimaryExpression__Group_13_1_2_0__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__0__Impl_in_rule__PrimaryExpression__Group_13_1_2_0__020751);
+ rule__PrimaryExpression__Group_13_1_2_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__1_in_rule__PrimaryExpression__Group_13_1_2_0__020754);
+ rule__PrimaryExpression__Group_13_1_2_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10137:1: rule__PrimaryExpression__Group_13_1_2_0__0__Impl : ( RULE_CATCH ) ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10141:1: ( ( RULE_CATCH ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10142:1: ( RULE_CATCH )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10142:1: ( RULE_CATCH )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10143:1: RULE_CATCH
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0());
+ }
+ match(input,RULE_CATCH,FOLLOW_RULE_CATCH_in_rule__PrimaryExpression__Group_13_1_2_0__0__Impl20781); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10154:1: rule__PrimaryExpression__Group_13_1_2_0__1 : rule__PrimaryExpression__Group_13_1_2_0__1__Impl rule__PrimaryExpression__Group_13_1_2_0__2 ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10158:1: ( rule__PrimaryExpression__Group_13_1_2_0__1__Impl rule__PrimaryExpression__Group_13_1_2_0__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10159:2: rule__PrimaryExpression__Group_13_1_2_0__1__Impl rule__PrimaryExpression__Group_13_1_2_0__2
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__1__Impl_in_rule__PrimaryExpression__Group_13_1_2_0__120810);
+ rule__PrimaryExpression__Group_13_1_2_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__2_in_rule__PrimaryExpression__Group_13_1_2_0__120813);
+ rule__PrimaryExpression__Group_13_1_2_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10166:1: rule__PrimaryExpression__Group_13_1_2_0__1__Impl : ( ( rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10170:1: ( ( ( rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10171:1: ( ( rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10171:1: ( ( rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10172:1: ( rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getExceptionAssignment_13_1_2_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10173:1: ( rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10173:2: rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1_in_rule__PrimaryExpression__Group_13_1_2_0__1__Impl20840);
+ rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getExceptionAssignment_13_1_2_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10183:1: rule__PrimaryExpression__Group_13_1_2_0__2 : rule__PrimaryExpression__Group_13_1_2_0__2__Impl rule__PrimaryExpression__Group_13_1_2_0__3 ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10187:1: ( rule__PrimaryExpression__Group_13_1_2_0__2__Impl rule__PrimaryExpression__Group_13_1_2_0__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10188:2: rule__PrimaryExpression__Group_13_1_2_0__2__Impl rule__PrimaryExpression__Group_13_1_2_0__3
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__2__Impl_in_rule__PrimaryExpression__Group_13_1_2_0__220870);
+ rule__PrimaryExpression__Group_13_1_2_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__3_in_rule__PrimaryExpression__Group_13_1_2_0__220873);
+ rule__PrimaryExpression__Group_13_1_2_0__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0__2"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10195:1: rule__PrimaryExpression__Group_13_1_2_0__2__Impl : ( ( rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2 ) ) ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10199:1: ( ( ( rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10200:1: ( ( rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10200:1: ( ( rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10201:1: ( rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getCatchBlockAssignment_13_1_2_0_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10202:1: ( rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10202:2: rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2_in_rule__PrimaryExpression__Group_13_1_2_0__2__Impl20900);
+ rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getCatchBlockAssignment_13_1_2_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0__2__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10212:1: rule__PrimaryExpression__Group_13_1_2_0__3 : rule__PrimaryExpression__Group_13_1_2_0__3__Impl ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10216:1: ( rule__PrimaryExpression__Group_13_1_2_0__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10217:2: rule__PrimaryExpression__Group_13_1_2_0__3__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__3__Impl_in_rule__PrimaryExpression__Group_13_1_2_0__320930);
+ rule__PrimaryExpression__Group_13_1_2_0__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0__3"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10223:1: rule__PrimaryExpression__Group_13_1_2_0__3__Impl : ( ( rule__PrimaryExpression__Group_13_1_2_0_3__0 )? ) ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10227:1: ( ( ( rule__PrimaryExpression__Group_13_1_2_0_3__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10228:1: ( ( rule__PrimaryExpression__Group_13_1_2_0_3__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10228:1: ( ( rule__PrimaryExpression__Group_13_1_2_0_3__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10229:1: ( rule__PrimaryExpression__Group_13_1_2_0_3__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10230:1: ( rule__PrimaryExpression__Group_13_1_2_0_3__0 )?
+ int alt80=2;
+ int LA80_0 = input.LA(1);
+
+ if ( (LA80_0==RULE_FINALLY) ) {
+ alt80=1;
+ }
+ switch (alt80) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10230:2: rule__PrimaryExpression__Group_13_1_2_0_3__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0_3__0_in_rule__PrimaryExpression__Group_13_1_2_0__3__Impl20957);
+ rule__PrimaryExpression__Group_13_1_2_0_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0__3__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0_3__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10248:1: rule__PrimaryExpression__Group_13_1_2_0_3__0 : rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl rule__PrimaryExpression__Group_13_1_2_0_3__1 ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0_3__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10252:1: ( rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl rule__PrimaryExpression__Group_13_1_2_0_3__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10253:2: rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl rule__PrimaryExpression__Group_13_1_2_0_3__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl_in_rule__PrimaryExpression__Group_13_1_2_0_3__020996);
+ rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0_3__1_in_rule__PrimaryExpression__Group_13_1_2_0_3__020999);
+ rule__PrimaryExpression__Group_13_1_2_0_3__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0_3__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10260:1: rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl : ( RULE_FINALLY ) ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10264:1: ( ( RULE_FINALLY ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10265:1: ( RULE_FINALLY )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10265:1: ( RULE_FINALLY )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10266:1: RULE_FINALLY
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0());
+ }
+ match(input,RULE_FINALLY,FOLLOW_RULE_FINALLY_in_rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl21026); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0_3__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10277:1: rule__PrimaryExpression__Group_13_1_2_0_3__1 : rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0_3__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10281:1: ( rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10282:2: rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl_in_rule__PrimaryExpression__Group_13_1_2_0_3__121055);
+ rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0_3__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10288:1: rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl : ( ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10292:1: ( ( ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10293:1: ( ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10293:1: ( ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10294:1: ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_0_3_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10295:1: ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10295:2: rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1_in_rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl21082);
+ rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_0_3_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10309:1: rule__PrimaryExpression__Group_13_1_2_1__0 : rule__PrimaryExpression__Group_13_1_2_1__0__Impl rule__PrimaryExpression__Group_13_1_2_1__1 ;
+ public final void rule__PrimaryExpression__Group_13_1_2_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10313:1: ( rule__PrimaryExpression__Group_13_1_2_1__0__Impl rule__PrimaryExpression__Group_13_1_2_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10314:2: rule__PrimaryExpression__Group_13_1_2_1__0__Impl rule__PrimaryExpression__Group_13_1_2_1__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_1__0__Impl_in_rule__PrimaryExpression__Group_13_1_2_1__021116);
+ rule__PrimaryExpression__Group_13_1_2_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_1__1_in_rule__PrimaryExpression__Group_13_1_2_1__021119);
+ rule__PrimaryExpression__Group_13_1_2_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_1__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10321:1: rule__PrimaryExpression__Group_13_1_2_1__0__Impl : ( RULE_FINALLY ) ;
+ public final void rule__PrimaryExpression__Group_13_1_2_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10325:1: ( ( RULE_FINALLY ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10326:1: ( RULE_FINALLY )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10326:1: ( RULE_FINALLY )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10327:1: RULE_FINALLY
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0());
+ }
+ match(input,RULE_FINALLY,FOLLOW_RULE_FINALLY_in_rule__PrimaryExpression__Group_13_1_2_1__0__Impl21146); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_1__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10338:1: rule__PrimaryExpression__Group_13_1_2_1__1 : rule__PrimaryExpression__Group_13_1_2_1__1__Impl ;
+ public final void rule__PrimaryExpression__Group_13_1_2_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10342:1: ( rule__PrimaryExpression__Group_13_1_2_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10343:2: rule__PrimaryExpression__Group_13_1_2_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_13_1_2_1__1__Impl_in_rule__PrimaryExpression__Group_13_1_2_1__121175);
+ rule__PrimaryExpression__Group_13_1_2_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_1__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_13_1_2_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10349:1: rule__PrimaryExpression__Group_13_1_2_1__1__Impl : ( ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_13_1_2_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10353:1: ( ( ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10354:1: ( ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10354:1: ( ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10355:1: ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10356:1: ( rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10356:2: rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1_in_rule__PrimaryExpression__Group_13_1_2_1__1__Impl21202);
+ rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_13_1_2_1__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10370:1: rule__PrimaryExpression__Group_14__0 : rule__PrimaryExpression__Group_14__0__Impl rule__PrimaryExpression__Group_14__1 ;
+ public final void rule__PrimaryExpression__Group_14__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10374:1: ( rule__PrimaryExpression__Group_14__0__Impl rule__PrimaryExpression__Group_14__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10375:2: rule__PrimaryExpression__Group_14__0__Impl rule__PrimaryExpression__Group_14__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14__0__Impl_in_rule__PrimaryExpression__Group_14__021236);
+ rule__PrimaryExpression__Group_14__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14__1_in_rule__PrimaryExpression__Group_14__021239);
+ rule__PrimaryExpression__Group_14__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10382:1: rule__PrimaryExpression__Group_14__0__Impl : ( () ) ;
+ public final void rule__PrimaryExpression__Group_14__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10386:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10387:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10387:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10388:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10389:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10391:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10401:1: rule__PrimaryExpression__Group_14__1 : rule__PrimaryExpression__Group_14__1__Impl ;
+ public final void rule__PrimaryExpression__Group_14__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10405:1: ( rule__PrimaryExpression__Group_14__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10406:2: rule__PrimaryExpression__Group_14__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14__1__Impl_in_rule__PrimaryExpression__Group_14__121297);
+ rule__PrimaryExpression__Group_14__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10412:1: rule__PrimaryExpression__Group_14__1__Impl : ( ( rule__PrimaryExpression__Group_14_1__0 ) ) ;
+ public final void rule__PrimaryExpression__Group_14__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10416:1: ( ( ( rule__PrimaryExpression__Group_14_1__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10417:1: ( ( rule__PrimaryExpression__Group_14_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10417:1: ( ( rule__PrimaryExpression__Group_14_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10418:1: ( rule__PrimaryExpression__Group_14_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10419:1: ( rule__PrimaryExpression__Group_14_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10419:2: rule__PrimaryExpression__Group_14_1__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__0_in_rule__PrimaryExpression__Group_14__1__Impl21324);
+ rule__PrimaryExpression__Group_14_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10433:1: rule__PrimaryExpression__Group_14_1__0 : rule__PrimaryExpression__Group_14_1__0__Impl rule__PrimaryExpression__Group_14_1__1 ;
+ public final void rule__PrimaryExpression__Group_14_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10437:1: ( rule__PrimaryExpression__Group_14_1__0__Impl rule__PrimaryExpression__Group_14_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10438:2: rule__PrimaryExpression__Group_14_1__0__Impl rule__PrimaryExpression__Group_14_1__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__0__Impl_in_rule__PrimaryExpression__Group_14_1__021358);
+ rule__PrimaryExpression__Group_14_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__1_in_rule__PrimaryExpression__Group_14_1__021361);
+ rule__PrimaryExpression__Group_14_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10445:1: rule__PrimaryExpression__Group_14_1__0__Impl : ( RULE_SWITCH ) ;
+ public final void rule__PrimaryExpression__Group_14_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10449:1: ( ( RULE_SWITCH ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10450:1: ( RULE_SWITCH )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10450:1: ( RULE_SWITCH )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10451:1: RULE_SWITCH
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0());
+ }
+ match(input,RULE_SWITCH,FOLLOW_RULE_SWITCH_in_rule__PrimaryExpression__Group_14_1__0__Impl21388); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10462:1: rule__PrimaryExpression__Group_14_1__1 : rule__PrimaryExpression__Group_14_1__1__Impl rule__PrimaryExpression__Group_14_1__2 ;
+ public final void rule__PrimaryExpression__Group_14_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10466:1: ( rule__PrimaryExpression__Group_14_1__1__Impl rule__PrimaryExpression__Group_14_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10467:2: rule__PrimaryExpression__Group_14_1__1__Impl rule__PrimaryExpression__Group_14_1__2
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__1__Impl_in_rule__PrimaryExpression__Group_14_1__121417);
+ rule__PrimaryExpression__Group_14_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__2_in_rule__PrimaryExpression__Group_14_1__121420);
+ rule__PrimaryExpression__Group_14_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10474:1: rule__PrimaryExpression__Group_14_1__1__Impl : ( ( rule__PrimaryExpression__ExpAssignment_14_1_1 )? ) ;
+ public final void rule__PrimaryExpression__Group_14_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10478:1: ( ( ( rule__PrimaryExpression__ExpAssignment_14_1_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10479:1: ( ( rule__PrimaryExpression__ExpAssignment_14_1_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10479:1: ( ( rule__PrimaryExpression__ExpAssignment_14_1_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10480:1: ( rule__PrimaryExpression__ExpAssignment_14_1_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getExpAssignment_14_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10481:1: ( rule__PrimaryExpression__ExpAssignment_14_1_1 )?
+ int alt81=2;
+ int LA81_0 = input.LA(1);
+
+ if ( ((LA81_0>=RULE_PLUS && LA81_0<=RULE_MINUS_MINUS)||(LA81_0>=RULE_AT_SIGIL && LA81_0<=RULE_BOUND_FUNC_ARROW)||LA81_0==RULE_PARAM_START||(LA81_0>=RULE_FOR && LA81_0<=RULE_WHILE)||LA81_0==RULE_UNTIL||LA81_0==RULE_LBRACKET||LA81_0==RULE_SUPER||(LA81_0>=RULE_THIS && LA81_0<=RULE_TRY)||LA81_0==RULE_SWITCH||LA81_0==RULE_LCURLY||(LA81_0>=RULE_NUMBER && LA81_0<=RULE_REGEX)||LA81_0==RULE_LPAREN||(LA81_0>=RULE_IF && LA81_0<=RULE_IDENTIFIER)) ) {
+ alt81=1;
+ }
+ switch (alt81) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10481:2: rule__PrimaryExpression__ExpAssignment_14_1_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__ExpAssignment_14_1_1_in_rule__PrimaryExpression__Group_14_1__1__Impl21447);
+ rule__PrimaryExpression__ExpAssignment_14_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getExpAssignment_14_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__1__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10491:1: rule__PrimaryExpression__Group_14_1__2 : rule__PrimaryExpression__Group_14_1__2__Impl rule__PrimaryExpression__Group_14_1__3 ;
+ public final void rule__PrimaryExpression__Group_14_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10495:1: ( rule__PrimaryExpression__Group_14_1__2__Impl rule__PrimaryExpression__Group_14_1__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10496:2: rule__PrimaryExpression__Group_14_1__2__Impl rule__PrimaryExpression__Group_14_1__3
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__2__Impl_in_rule__PrimaryExpression__Group_14_1__221478);
+ rule__PrimaryExpression__Group_14_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__3_in_rule__PrimaryExpression__Group_14_1__221481);
+ rule__PrimaryExpression__Group_14_1__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__2"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10503:1: rule__PrimaryExpression__Group_14_1__2__Impl : ( RULE_INDENT ) ;
+ public final void rule__PrimaryExpression__Group_14_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10507:1: ( ( RULE_INDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10508:1: ( RULE_INDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10508:1: ( RULE_INDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10509:1: RULE_INDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2());
+ }
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rule__PrimaryExpression__Group_14_1__2__Impl21508); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__2__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10520:1: rule__PrimaryExpression__Group_14_1__3 : rule__PrimaryExpression__Group_14_1__3__Impl rule__PrimaryExpression__Group_14_1__4 ;
+ public final void rule__PrimaryExpression__Group_14_1__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10524:1: ( rule__PrimaryExpression__Group_14_1__3__Impl rule__PrimaryExpression__Group_14_1__4 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10525:2: rule__PrimaryExpression__Group_14_1__3__Impl rule__PrimaryExpression__Group_14_1__4
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__3__Impl_in_rule__PrimaryExpression__Group_14_1__321537);
+ rule__PrimaryExpression__Group_14_1__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__4_in_rule__PrimaryExpression__Group_14_1__321540);
+ rule__PrimaryExpression__Group_14_1__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__3"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10532:1: rule__PrimaryExpression__Group_14_1__3__Impl : ( ( rule__PrimaryExpression__CasesAssignment_14_1_3 )* ) ;
+ public final void rule__PrimaryExpression__Group_14_1__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10536:1: ( ( ( rule__PrimaryExpression__CasesAssignment_14_1_3 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10537:1: ( ( rule__PrimaryExpression__CasesAssignment_14_1_3 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10537:1: ( ( rule__PrimaryExpression__CasesAssignment_14_1_3 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10538:1: ( rule__PrimaryExpression__CasesAssignment_14_1_3 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_14_1_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10539:1: ( rule__PrimaryExpression__CasesAssignment_14_1_3 )*
+ loop82:
+ do {
+ int alt82=2;
+ int LA82_0 = input.LA(1);
+
+ if ( (LA82_0==RULE_LEADING_WHEN) ) {
+ alt82=1;
+ }
+
+
+ switch (alt82) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10539:2: rule__PrimaryExpression__CasesAssignment_14_1_3
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__CasesAssignment_14_1_3_in_rule__PrimaryExpression__Group_14_1__3__Impl21567);
+ rule__PrimaryExpression__CasesAssignment_14_1_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop82;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_14_1_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__3__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__4"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10549:1: rule__PrimaryExpression__Group_14_1__4 : rule__PrimaryExpression__Group_14_1__4__Impl rule__PrimaryExpression__Group_14_1__5 ;
+ public final void rule__PrimaryExpression__Group_14_1__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10553:1: ( rule__PrimaryExpression__Group_14_1__4__Impl rule__PrimaryExpression__Group_14_1__5 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10554:2: rule__PrimaryExpression__Group_14_1__4__Impl rule__PrimaryExpression__Group_14_1__5
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__4__Impl_in_rule__PrimaryExpression__Group_14_1__421598);
+ rule__PrimaryExpression__Group_14_1__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__5_in_rule__PrimaryExpression__Group_14_1__421601);
+ rule__PrimaryExpression__Group_14_1__5();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__4"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__4__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10561:1: rule__PrimaryExpression__Group_14_1__4__Impl : ( ( rule__PrimaryExpression__Group_14_1_4__0 )? ) ;
+ public final void rule__PrimaryExpression__Group_14_1__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10565:1: ( ( ( rule__PrimaryExpression__Group_14_1_4__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10566:1: ( ( rule__PrimaryExpression__Group_14_1_4__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10566:1: ( ( rule__PrimaryExpression__Group_14_1_4__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10567:1: ( rule__PrimaryExpression__Group_14_1_4__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1_4());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10568:1: ( rule__PrimaryExpression__Group_14_1_4__0 )?
+ int alt83=2;
+ int LA83_0 = input.LA(1);
+
+ if ( (LA83_0==RULE_ELSE) ) {
+ alt83=1;
+ }
+ switch (alt83) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10568:2: rule__PrimaryExpression__Group_14_1_4__0
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1_4__0_in_rule__PrimaryExpression__Group_14_1__4__Impl21628);
+ rule__PrimaryExpression__Group_14_1_4__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getGroup_14_1_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__4__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__5"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10578:1: rule__PrimaryExpression__Group_14_1__5 : rule__PrimaryExpression__Group_14_1__5__Impl ;
+ public final void rule__PrimaryExpression__Group_14_1__5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10582:1: ( rule__PrimaryExpression__Group_14_1__5__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10583:2: rule__PrimaryExpression__Group_14_1__5__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1__5__Impl_in_rule__PrimaryExpression__Group_14_1__521659);
+ rule__PrimaryExpression__Group_14_1__5__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__5"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1__5__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10589:1: rule__PrimaryExpression__Group_14_1__5__Impl : ( RULE_OUTDENT ) ;
+ public final void rule__PrimaryExpression__Group_14_1__5__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10593:1: ( ( RULE_OUTDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10594:1: ( RULE_OUTDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10594:1: ( RULE_OUTDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10595:1: RULE_OUTDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5());
+ }
+ match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rule__PrimaryExpression__Group_14_1__5__Impl21686); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1__5__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1_4__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10618:1: rule__PrimaryExpression__Group_14_1_4__0 : rule__PrimaryExpression__Group_14_1_4__0__Impl rule__PrimaryExpression__Group_14_1_4__1 ;
+ public final void rule__PrimaryExpression__Group_14_1_4__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10622:1: ( rule__PrimaryExpression__Group_14_1_4__0__Impl rule__PrimaryExpression__Group_14_1_4__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10623:2: rule__PrimaryExpression__Group_14_1_4__0__Impl rule__PrimaryExpression__Group_14_1_4__1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1_4__0__Impl_in_rule__PrimaryExpression__Group_14_1_4__021727);
+ rule__PrimaryExpression__Group_14_1_4__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1_4__1_in_rule__PrimaryExpression__Group_14_1_4__021730);
+ rule__PrimaryExpression__Group_14_1_4__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1_4__0"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1_4__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10630:1: rule__PrimaryExpression__Group_14_1_4__0__Impl : ( RULE_ELSE ) ;
+ public final void rule__PrimaryExpression__Group_14_1_4__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10634:1: ( ( RULE_ELSE ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10635:1: ( RULE_ELSE )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10635:1: ( RULE_ELSE )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10636:1: RULE_ELSE
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0());
+ }
+ match(input,RULE_ELSE,FOLLOW_RULE_ELSE_in_rule__PrimaryExpression__Group_14_1_4__0__Impl21757); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1_4__0__Impl"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1_4__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10647:1: rule__PrimaryExpression__Group_14_1_4__1 : rule__PrimaryExpression__Group_14_1_4__1__Impl ;
+ public final void rule__PrimaryExpression__Group_14_1_4__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10651:1: ( rule__PrimaryExpression__Group_14_1_4__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10652:2: rule__PrimaryExpression__Group_14_1_4__1__Impl
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__Group_14_1_4__1__Impl_in_rule__PrimaryExpression__Group_14_1_4__121786);
+ rule__PrimaryExpression__Group_14_1_4__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1_4__1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__Group_14_1_4__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10658:1: rule__PrimaryExpression__Group_14_1_4__1__Impl : ( ( rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1 ) ) ;
+ public final void rule__PrimaryExpression__Group_14_1_4__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10662:1: ( ( ( rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10663:1: ( ( rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10663:1: ( ( rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10664:1: ( rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getElseBlockAssignment_14_1_4_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10665:1: ( rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10665:2: rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1
+ {
+ pushFollow(FOLLOW_rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1_in_rule__PrimaryExpression__Group_14_1_4__1__Impl21813);
+ rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getElseBlockAssignment_14_1_4_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__Group_14_1_4__1__Impl"
+
+
+ // $ANTLR start "rule__Block__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10679:1: rule__Block__Group__0 : rule__Block__Group__0__Impl rule__Block__Group__1 ;
+ public final void rule__Block__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10683:1: ( rule__Block__Group__0__Impl rule__Block__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10684:2: rule__Block__Group__0__Impl rule__Block__Group__1
+ {
+ pushFollow(FOLLOW_rule__Block__Group__0__Impl_in_rule__Block__Group__021847);
+ rule__Block__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Block__Group__1_in_rule__Block__Group__021850);
+ rule__Block__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Block__Group__0"
+
+
+ // $ANTLR start "rule__Block__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10691:1: rule__Block__Group__0__Impl : ( () ) ;
+ public final void rule__Block__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10695:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10696:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10696:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10697:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBlockAccess().getBlockAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10698:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10700:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBlockAccess().getBlockAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Block__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Block__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10710:1: rule__Block__Group__1 : rule__Block__Group__1__Impl rule__Block__Group__2 ;
+ public final void rule__Block__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10714:1: ( rule__Block__Group__1__Impl rule__Block__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10715:2: rule__Block__Group__1__Impl rule__Block__Group__2
+ {
+ pushFollow(FOLLOW_rule__Block__Group__1__Impl_in_rule__Block__Group__121908);
+ rule__Block__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Block__Group__2_in_rule__Block__Group__121911);
+ rule__Block__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Block__Group__1"
+
+
+ // $ANTLR start "rule__Block__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10722:1: rule__Block__Group__1__Impl : ( RULE_INDENT ) ;
+ public final void rule__Block__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10726:1: ( ( RULE_INDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10727:1: ( RULE_INDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10727:1: ( RULE_INDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10728:1: RULE_INDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1());
+ }
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rule__Block__Group__1__Impl21938); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Block__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Block__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10739:1: rule__Block__Group__2 : rule__Block__Group__2__Impl rule__Block__Group__3 ;
+ public final void rule__Block__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10743:1: ( rule__Block__Group__2__Impl rule__Block__Group__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10744:2: rule__Block__Group__2__Impl rule__Block__Group__3
+ {
+ pushFollow(FOLLOW_rule__Block__Group__2__Impl_in_rule__Block__Group__221967);
+ rule__Block__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Block__Group__3_in_rule__Block__Group__221970);
+ rule__Block__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Block__Group__2"
+
+
+ // $ANTLR start "rule__Block__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10751:1: rule__Block__Group__2__Impl : ( ( ruleBody )? ) ;
+ public final void rule__Block__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10755:1: ( ( ( ruleBody )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10756:1: ( ( ruleBody )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10756:1: ( ( ruleBody )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10757:1: ( ruleBody )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBlockAccess().getBodyParserRuleCall_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10758:1: ( ruleBody )?
+ int alt84=2;
+ int LA84_0 = input.LA(1);
+
+ if ( ((LA84_0>=RULE_PLUS && LA84_0<=RULE_MINUS_MINUS)||(LA84_0>=RULE_AT_SIGIL && LA84_0<=RULE_BOUND_FUNC_ARROW)||LA84_0==RULE_PARAM_START||LA84_0==RULE_RETURN||(LA84_0>=RULE_THROW && LA84_0<=RULE_CLASS)||(LA84_0>=RULE_FOR && LA84_0<=RULE_WHILE)||LA84_0==RULE_UNTIL||LA84_0==RULE_LBRACKET||LA84_0==RULE_SUPER||(LA84_0>=RULE_THIS && LA84_0<=RULE_TRY)||LA84_0==RULE_SWITCH||LA84_0==RULE_LCURLY||(LA84_0>=RULE_NUMBER && LA84_0<=RULE_REGEX)||(LA84_0>=RULE_LPAREN && LA84_0<=RULE_HERECOMMENT)||(LA84_0>=RULE_IF && LA84_0<=RULE_IDENTIFIER)) ) {
+ alt84=1;
+ }
+ switch (alt84) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10758:3: ruleBody
+ {
+ pushFollow(FOLLOW_ruleBody_in_rule__Block__Group__2__Impl21998);
+ ruleBody();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBlockAccess().getBodyParserRuleCall_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Block__Group__2__Impl"
+
+
+ // $ANTLR start "rule__Block__Group__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10768:1: rule__Block__Group__3 : rule__Block__Group__3__Impl ;
+ public final void rule__Block__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10772:1: ( rule__Block__Group__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10773:2: rule__Block__Group__3__Impl
+ {
+ pushFollow(FOLLOW_rule__Block__Group__3__Impl_in_rule__Block__Group__322029);
+ rule__Block__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Block__Group__3"
+
+
+ // $ANTLR start "rule__Block__Group__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10779:1: rule__Block__Group__3__Impl : ( RULE_OUTDENT ) ;
+ public final void rule__Block__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10783:1: ( ( RULE_OUTDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10784:1: ( RULE_OUTDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10784:1: ( RULE_OUTDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10785:1: RULE_OUTDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3());
+ }
+ match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rule__Block__Group__3__Impl22056); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Block__Group__3__Impl"
+
+
+ // $ANTLR start "rule__Case__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10804:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ;
+ public final void rule__Case__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10808:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10809:2: rule__Case__Group__0__Impl rule__Case__Group__1
+ {
+ pushFollow(FOLLOW_rule__Case__Group__0__Impl_in_rule__Case__Group__022093);
+ rule__Case__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Case__Group__1_in_rule__Case__Group__022096);
+ rule__Case__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__0"
+
+
+ // $ANTLR start "rule__Case__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10816:1: rule__Case__Group__0__Impl : ( RULE_LEADING_WHEN ) ;
+ public final void rule__Case__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10820:1: ( ( RULE_LEADING_WHEN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10821:1: ( RULE_LEADING_WHEN )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10821:1: ( RULE_LEADING_WHEN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10822:1: RULE_LEADING_WHEN
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0());
+ }
+ match(input,RULE_LEADING_WHEN,FOLLOW_RULE_LEADING_WHEN_in_rule__Case__Group__0__Impl22123); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Case__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10833:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ;
+ public final void rule__Case__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10837:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10838:2: rule__Case__Group__1__Impl rule__Case__Group__2
+ {
+ pushFollow(FOLLOW_rule__Case__Group__1__Impl_in_rule__Case__Group__122152);
+ rule__Case__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Case__Group__2_in_rule__Case__Group__122155);
+ rule__Case__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__1"
+
+
+ // $ANTLR start "rule__Case__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10845:1: rule__Case__Group__1__Impl : ( ( rule__Case__WhensAssignment_1 ) ) ;
+ public final void rule__Case__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10849:1: ( ( ( rule__Case__WhensAssignment_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10850:1: ( ( rule__Case__WhensAssignment_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10850:1: ( ( rule__Case__WhensAssignment_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10851:1: ( rule__Case__WhensAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getWhensAssignment_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10852:1: ( rule__Case__WhensAssignment_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10852:2: rule__Case__WhensAssignment_1
+ {
+ pushFollow(FOLLOW_rule__Case__WhensAssignment_1_in_rule__Case__Group__1__Impl22182);
+ rule__Case__WhensAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getWhensAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Case__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10862:1: rule__Case__Group__2 : rule__Case__Group__2__Impl rule__Case__Group__3 ;
+ public final void rule__Case__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10866:1: ( rule__Case__Group__2__Impl rule__Case__Group__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10867:2: rule__Case__Group__2__Impl rule__Case__Group__3
+ {
+ pushFollow(FOLLOW_rule__Case__Group__2__Impl_in_rule__Case__Group__222212);
+ rule__Case__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Case__Group__3_in_rule__Case__Group__222215);
+ rule__Case__Group__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__2"
+
+
+ // $ANTLR start "rule__Case__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10874:1: rule__Case__Group__2__Impl : ( ( rule__Case__Group_2__0 )* ) ;
+ public final void rule__Case__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10878:1: ( ( ( rule__Case__Group_2__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10879:1: ( ( rule__Case__Group_2__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10879:1: ( ( rule__Case__Group_2__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10880:1: ( rule__Case__Group_2__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getGroup_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10881:1: ( rule__Case__Group_2__0 )*
+ loop85:
+ do {
+ int alt85=2;
+ int LA85_0 = input.LA(1);
+
+ if ( (LA85_0==RULE_COMMA) ) {
+ alt85=1;
+ }
+
+
+ switch (alt85) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10881:2: rule__Case__Group_2__0
+ {
+ pushFollow(FOLLOW_rule__Case__Group_2__0_in_rule__Case__Group__2__Impl22242);
+ rule__Case__Group_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop85;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getGroup_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__2__Impl"
+
+
+ // $ANTLR start "rule__Case__Group__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10891:1: rule__Case__Group__3 : rule__Case__Group__3__Impl rule__Case__Group__4 ;
+ public final void rule__Case__Group__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10895:1: ( rule__Case__Group__3__Impl rule__Case__Group__4 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10896:2: rule__Case__Group__3__Impl rule__Case__Group__4
+ {
+ pushFollow(FOLLOW_rule__Case__Group__3__Impl_in_rule__Case__Group__322273);
+ rule__Case__Group__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Case__Group__4_in_rule__Case__Group__322276);
+ rule__Case__Group__4();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__3"
+
+
+ // $ANTLR start "rule__Case__Group__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10903:1: rule__Case__Group__3__Impl : ( ( rule__Case__ThenAssignment_3 ) ) ;
+ public final void rule__Case__Group__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10907:1: ( ( ( rule__Case__ThenAssignment_3 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10908:1: ( ( rule__Case__ThenAssignment_3 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10908:1: ( ( rule__Case__ThenAssignment_3 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10909:1: ( rule__Case__ThenAssignment_3 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getThenAssignment_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10910:1: ( rule__Case__ThenAssignment_3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10910:2: rule__Case__ThenAssignment_3
+ {
+ pushFollow(FOLLOW_rule__Case__ThenAssignment_3_in_rule__Case__Group__3__Impl22303);
+ rule__Case__ThenAssignment_3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getThenAssignment_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__3__Impl"
+
+
+ // $ANTLR start "rule__Case__Group__4"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10920:1: rule__Case__Group__4 : rule__Case__Group__4__Impl ;
+ public final void rule__Case__Group__4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10924:1: ( rule__Case__Group__4__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10925:2: rule__Case__Group__4__Impl
+ {
+ pushFollow(FOLLOW_rule__Case__Group__4__Impl_in_rule__Case__Group__422333);
+ rule__Case__Group__4__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__4"
+
+
+ // $ANTLR start "rule__Case__Group__4__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10931:1: rule__Case__Group__4__Impl : ( ( RULE_TERMINATOR )? ) ;
+ public final void rule__Case__Group__4__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10935:1: ( ( ( RULE_TERMINATOR )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10936:1: ( ( RULE_TERMINATOR )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10936:1: ( ( RULE_TERMINATOR )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10937:1: ( RULE_TERMINATOR )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getTERMINATORTerminalRuleCall_4());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10938:1: ( RULE_TERMINATOR )?
+ int alt86=2;
+ int LA86_0 = input.LA(1);
+
+ if ( (LA86_0==RULE_TERMINATOR) ) {
+ alt86=1;
+ }
+ switch (alt86) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10938:3: RULE_TERMINATOR
+ {
+ match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_rule__Case__Group__4__Impl22361); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getTERMINATORTerminalRuleCall_4());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group__4__Impl"
+
+
+ // $ANTLR start "rule__Case__Group_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10958:1: rule__Case__Group_2__0 : rule__Case__Group_2__0__Impl rule__Case__Group_2__1 ;
+ public final void rule__Case__Group_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10962:1: ( rule__Case__Group_2__0__Impl rule__Case__Group_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10963:2: rule__Case__Group_2__0__Impl rule__Case__Group_2__1
+ {
+ pushFollow(FOLLOW_rule__Case__Group_2__0__Impl_in_rule__Case__Group_2__022402);
+ rule__Case__Group_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Case__Group_2__1_in_rule__Case__Group_2__022405);
+ rule__Case__Group_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group_2__0"
+
+
+ // $ANTLR start "rule__Case__Group_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10970:1: rule__Case__Group_2__0__Impl : ( RULE_COMMA ) ;
+ public final void rule__Case__Group_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10974:1: ( ( RULE_COMMA ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10975:1: ( RULE_COMMA )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10975:1: ( RULE_COMMA )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10976:1: RULE_COMMA
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0());
+ }
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__Case__Group_2__0__Impl22432); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group_2__0__Impl"
+
+
+ // $ANTLR start "rule__Case__Group_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10987:1: rule__Case__Group_2__1 : rule__Case__Group_2__1__Impl ;
+ public final void rule__Case__Group_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10991:1: ( rule__Case__Group_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10992:2: rule__Case__Group_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Case__Group_2__1__Impl_in_rule__Case__Group_2__122461);
+ rule__Case__Group_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group_2__1"
+
+
+ // $ANTLR start "rule__Case__Group_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:10998:1: rule__Case__Group_2__1__Impl : ( ( rule__Case__WhensAssignment_2_1 ) ) ;
+ public final void rule__Case__Group_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11002:1: ( ( ( rule__Case__WhensAssignment_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11003:1: ( ( rule__Case__WhensAssignment_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11003:1: ( ( rule__Case__WhensAssignment_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11004:1: ( rule__Case__WhensAssignment_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getWhensAssignment_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11005:1: ( rule__Case__WhensAssignment_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11005:2: rule__Case__WhensAssignment_2_1
+ {
+ pushFollow(FOLLOW_rule__Case__WhensAssignment_2_1_in_rule__Case__Group_2__1__Impl22488);
+ rule__Case__WhensAssignment_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getWhensAssignment_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__Group_2__1__Impl"
+
+
+ // $ANTLR start "rule__IfExp__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11019:1: rule__IfExp__Group__0 : rule__IfExp__Group__0__Impl rule__IfExp__Group__1 ;
+ public final void rule__IfExp__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11023:1: ( rule__IfExp__Group__0__Impl rule__IfExp__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11024:2: rule__IfExp__Group__0__Impl rule__IfExp__Group__1
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group__0__Impl_in_rule__IfExp__Group__022522);
+ rule__IfExp__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__IfExp__Group__1_in_rule__IfExp__Group__022525);
+ rule__IfExp__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group__0"
+
+
+ // $ANTLR start "rule__IfExp__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11031:1: rule__IfExp__Group__0__Impl : ( ( rule__IfExp__BlocksAssignment_0 ) ) ;
+ public final void rule__IfExp__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11035:1: ( ( ( rule__IfExp__BlocksAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11036:1: ( ( rule__IfExp__BlocksAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11036:1: ( ( rule__IfExp__BlocksAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11037:1: ( rule__IfExp__BlocksAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getBlocksAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11038:1: ( rule__IfExp__BlocksAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11038:2: rule__IfExp__BlocksAssignment_0
+ {
+ pushFollow(FOLLOW_rule__IfExp__BlocksAssignment_0_in_rule__IfExp__Group__0__Impl22552);
+ rule__IfExp__BlocksAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getBlocksAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group__0__Impl"
+
+
+ // $ANTLR start "rule__IfExp__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11048:1: rule__IfExp__Group__1 : rule__IfExp__Group__1__Impl rule__IfExp__Group__2 ;
+ public final void rule__IfExp__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11052:1: ( rule__IfExp__Group__1__Impl rule__IfExp__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11053:2: rule__IfExp__Group__1__Impl rule__IfExp__Group__2
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group__1__Impl_in_rule__IfExp__Group__122582);
+ rule__IfExp__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__IfExp__Group__2_in_rule__IfExp__Group__122585);
+ rule__IfExp__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group__1"
+
+
+ // $ANTLR start "rule__IfExp__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11060:1: rule__IfExp__Group__1__Impl : ( ( rule__IfExp__Group_1__0 )* ) ;
+ public final void rule__IfExp__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11064:1: ( ( ( rule__IfExp__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11065:1: ( ( rule__IfExp__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11065:1: ( ( rule__IfExp__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11066:1: ( rule__IfExp__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11067:1: ( rule__IfExp__Group_1__0 )*
+ loop87:
+ do {
+ int alt87=2;
+ int LA87_0 = input.LA(1);
+
+ if ( (LA87_0==RULE_ELSE) ) {
+ int LA87_1 = input.LA(2);
+
+ if ( (LA87_1==RULE_IF) ) {
+ alt87=1;
+ }
+
+
+ }
+
+
+ switch (alt87) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11067:2: rule__IfExp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group_1__0_in_rule__IfExp__Group__1__Impl22612);
+ rule__IfExp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop87;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group__1__Impl"
+
+
+ // $ANTLR start "rule__IfExp__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11077:1: rule__IfExp__Group__2 : rule__IfExp__Group__2__Impl ;
+ public final void rule__IfExp__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11081:1: ( rule__IfExp__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11082:2: rule__IfExp__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group__2__Impl_in_rule__IfExp__Group__222643);
+ rule__IfExp__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group__2"
+
+
+ // $ANTLR start "rule__IfExp__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11088:1: rule__IfExp__Group__2__Impl : ( ( rule__IfExp__Group_2__0 )? ) ;
+ public final void rule__IfExp__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11092:1: ( ( ( rule__IfExp__Group_2__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11093:1: ( ( rule__IfExp__Group_2__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11093:1: ( ( rule__IfExp__Group_2__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11094:1: ( rule__IfExp__Group_2__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getGroup_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11095:1: ( rule__IfExp__Group_2__0 )?
+ int alt88=2;
+ int LA88_0 = input.LA(1);
+
+ if ( (LA88_0==RULE_ELSE) ) {
+ alt88=1;
+ }
+ switch (alt88) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11095:2: rule__IfExp__Group_2__0
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group_2__0_in_rule__IfExp__Group__2__Impl22670);
+ rule__IfExp__Group_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getGroup_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group__2__Impl"
+
+
+ // $ANTLR start "rule__IfExp__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11111:1: rule__IfExp__Group_1__0 : rule__IfExp__Group_1__0__Impl rule__IfExp__Group_1__1 ;
+ public final void rule__IfExp__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11115:1: ( rule__IfExp__Group_1__0__Impl rule__IfExp__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11116:2: rule__IfExp__Group_1__0__Impl rule__IfExp__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group_1__0__Impl_in_rule__IfExp__Group_1__022707);
+ rule__IfExp__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__IfExp__Group_1__1_in_rule__IfExp__Group_1__022710);
+ rule__IfExp__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group_1__0"
+
+
+ // $ANTLR start "rule__IfExp__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11123:1: rule__IfExp__Group_1__0__Impl : ( RULE_ELSE ) ;
+ public final void rule__IfExp__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11127:1: ( ( RULE_ELSE ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11128:1: ( RULE_ELSE )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11128:1: ( RULE_ELSE )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11129:1: RULE_ELSE
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0());
+ }
+ match(input,RULE_ELSE,FOLLOW_RULE_ELSE_in_rule__IfExp__Group_1__0__Impl22737); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__IfExp__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11140:1: rule__IfExp__Group_1__1 : rule__IfExp__Group_1__1__Impl ;
+ public final void rule__IfExp__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11144:1: ( rule__IfExp__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11145:2: rule__IfExp__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group_1__1__Impl_in_rule__IfExp__Group_1__122766);
+ rule__IfExp__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group_1__1"
+
+
+ // $ANTLR start "rule__IfExp__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11151:1: rule__IfExp__Group_1__1__Impl : ( ( rule__IfExp__BlocksAssignment_1_1 ) ) ;
+ public final void rule__IfExp__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11155:1: ( ( ( rule__IfExp__BlocksAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11156:1: ( ( rule__IfExp__BlocksAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11156:1: ( ( rule__IfExp__BlocksAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11157:1: ( rule__IfExp__BlocksAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getBlocksAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11158:1: ( rule__IfExp__BlocksAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11158:2: rule__IfExp__BlocksAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__IfExp__BlocksAssignment_1_1_in_rule__IfExp__Group_1__1__Impl22793);
+ rule__IfExp__BlocksAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getBlocksAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__IfExp__Group_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11172:1: rule__IfExp__Group_2__0 : rule__IfExp__Group_2__0__Impl rule__IfExp__Group_2__1 ;
+ public final void rule__IfExp__Group_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11176:1: ( rule__IfExp__Group_2__0__Impl rule__IfExp__Group_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11177:2: rule__IfExp__Group_2__0__Impl rule__IfExp__Group_2__1
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group_2__0__Impl_in_rule__IfExp__Group_2__022827);
+ rule__IfExp__Group_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__IfExp__Group_2__1_in_rule__IfExp__Group_2__022830);
+ rule__IfExp__Group_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group_2__0"
+
+
+ // $ANTLR start "rule__IfExp__Group_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11184:1: rule__IfExp__Group_2__0__Impl : ( RULE_ELSE ) ;
+ public final void rule__IfExp__Group_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11188:1: ( ( RULE_ELSE ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11189:1: ( RULE_ELSE )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11189:1: ( RULE_ELSE )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11190:1: RULE_ELSE
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0());
+ }
+ match(input,RULE_ELSE,FOLLOW_RULE_ELSE_in_rule__IfExp__Group_2__0__Impl22857); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group_2__0__Impl"
+
+
+ // $ANTLR start "rule__IfExp__Group_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11201:1: rule__IfExp__Group_2__1 : rule__IfExp__Group_2__1__Impl ;
+ public final void rule__IfExp__Group_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11205:1: ( rule__IfExp__Group_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11206:2: rule__IfExp__Group_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__IfExp__Group_2__1__Impl_in_rule__IfExp__Group_2__122886);
+ rule__IfExp__Group_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group_2__1"
+
+
+ // $ANTLR start "rule__IfExp__Group_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11212:1: rule__IfExp__Group_2__1__Impl : ( ( rule__IfExp__DefaultBlockAssignment_2_1 ) ) ;
+ public final void rule__IfExp__Group_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11216:1: ( ( ( rule__IfExp__DefaultBlockAssignment_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11217:1: ( ( rule__IfExp__DefaultBlockAssignment_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11217:1: ( ( rule__IfExp__DefaultBlockAssignment_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11218:1: ( rule__IfExp__DefaultBlockAssignment_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getDefaultBlockAssignment_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11219:1: ( rule__IfExp__DefaultBlockAssignment_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11219:2: rule__IfExp__DefaultBlockAssignment_2_1
+ {
+ pushFollow(FOLLOW_rule__IfExp__DefaultBlockAssignment_2_1_in_rule__IfExp__Group_2__1__Impl22913);
+ rule__IfExp__DefaultBlockAssignment_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getDefaultBlockAssignment_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__Group_2__1__Impl"
+
+
+ // $ANTLR start "rule__CondBlock__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11233:1: rule__CondBlock__Group__0 : rule__CondBlock__Group__0__Impl rule__CondBlock__Group__1 ;
+ public final void rule__CondBlock__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11237:1: ( rule__CondBlock__Group__0__Impl rule__CondBlock__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11238:2: rule__CondBlock__Group__0__Impl rule__CondBlock__Group__1
+ {
+ pushFollow(FOLLOW_rule__CondBlock__Group__0__Impl_in_rule__CondBlock__Group__022947);
+ rule__CondBlock__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__CondBlock__Group__1_in_rule__CondBlock__Group__022950);
+ rule__CondBlock__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CondBlock__Group__0"
+
+
+ // $ANTLR start "rule__CondBlock__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11245:1: rule__CondBlock__Group__0__Impl : ( ( rule__CondBlock__OperatorAssignment_0 ) ) ;
+ public final void rule__CondBlock__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11249:1: ( ( ( rule__CondBlock__OperatorAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11250:1: ( ( rule__CondBlock__OperatorAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11250:1: ( ( rule__CondBlock__OperatorAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11251:1: ( rule__CondBlock__OperatorAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCondBlockAccess().getOperatorAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11252:1: ( rule__CondBlock__OperatorAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11252:2: rule__CondBlock__OperatorAssignment_0
+ {
+ pushFollow(FOLLOW_rule__CondBlock__OperatorAssignment_0_in_rule__CondBlock__Group__0__Impl22977);
+ rule__CondBlock__OperatorAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCondBlockAccess().getOperatorAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CondBlock__Group__0__Impl"
+
+
+ // $ANTLR start "rule__CondBlock__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11262:1: rule__CondBlock__Group__1 : rule__CondBlock__Group__1__Impl rule__CondBlock__Group__2 ;
+ public final void rule__CondBlock__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11266:1: ( rule__CondBlock__Group__1__Impl rule__CondBlock__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11267:2: rule__CondBlock__Group__1__Impl rule__CondBlock__Group__2
+ {
+ pushFollow(FOLLOW_rule__CondBlock__Group__1__Impl_in_rule__CondBlock__Group__123007);
+ rule__CondBlock__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__CondBlock__Group__2_in_rule__CondBlock__Group__123010);
+ rule__CondBlock__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CondBlock__Group__1"
+
+
+ // $ANTLR start "rule__CondBlock__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11274:1: rule__CondBlock__Group__1__Impl : ( ( rule__CondBlock__ConditionAssignment_1 ) ) ;
+ public final void rule__CondBlock__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11278:1: ( ( ( rule__CondBlock__ConditionAssignment_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11279:1: ( ( rule__CondBlock__ConditionAssignment_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11279:1: ( ( rule__CondBlock__ConditionAssignment_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11280:1: ( rule__CondBlock__ConditionAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCondBlockAccess().getConditionAssignment_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11281:1: ( rule__CondBlock__ConditionAssignment_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11281:2: rule__CondBlock__ConditionAssignment_1
+ {
+ pushFollow(FOLLOW_rule__CondBlock__ConditionAssignment_1_in_rule__CondBlock__Group__1__Impl23037);
+ rule__CondBlock__ConditionAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCondBlockAccess().getConditionAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CondBlock__Group__1__Impl"
+
+
+ // $ANTLR start "rule__CondBlock__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11291:1: rule__CondBlock__Group__2 : rule__CondBlock__Group__2__Impl ;
+ public final void rule__CondBlock__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11295:1: ( rule__CondBlock__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11296:2: rule__CondBlock__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__CondBlock__Group__2__Impl_in_rule__CondBlock__Group__223067);
+ rule__CondBlock__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CondBlock__Group__2"
+
+
+ // $ANTLR start "rule__CondBlock__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11302:1: rule__CondBlock__Group__2__Impl : ( ( rule__CondBlock__ActionAssignment_2 ) ) ;
+ public final void rule__CondBlock__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11306:1: ( ( ( rule__CondBlock__ActionAssignment_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11307:1: ( ( rule__CondBlock__ActionAssignment_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11307:1: ( ( rule__CondBlock__ActionAssignment_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11308:1: ( rule__CondBlock__ActionAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCondBlockAccess().getActionAssignment_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11309:1: ( rule__CondBlock__ActionAssignment_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11309:2: rule__CondBlock__ActionAssignment_2
+ {
+ pushFollow(FOLLOW_rule__CondBlock__ActionAssignment_2_in_rule__CondBlock__Group__2__Impl23094);
+ rule__CondBlock__ActionAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCondBlockAccess().getActionAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CondBlock__Group__2__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11325:1: rule__Property__Group_0__0 : rule__Property__Group_0__0__Impl rule__Property__Group_0__1 ;
+ public final void rule__Property__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11329:1: ( rule__Property__Group_0__0__Impl rule__Property__Group_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11330:2: rule__Property__Group_0__0__Impl rule__Property__Group_0__1
+ {
+ pushFollow(FOLLOW_rule__Property__Group_0__0__Impl_in_rule__Property__Group_0__023130);
+ rule__Property__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Property__Group_0__1_in_rule__Property__Group_0__023133);
+ rule__Property__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0__0"
+
+
+ // $ANTLR start "rule__Property__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11337:1: rule__Property__Group_0__0__Impl : ( ( rule__Property__Group_0_0__0 ) ) ;
+ public final void rule__Property__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11341:1: ( ( ( rule__Property__Group_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11342:1: ( ( rule__Property__Group_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11342:1: ( ( rule__Property__Group_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11343:1: ( rule__Property__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getGroup_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11344:1: ( rule__Property__Group_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11344:2: rule__Property__Group_0_0__0
+ {
+ pushFollow(FOLLOW_rule__Property__Group_0_0__0_in_rule__Property__Group_0__0__Impl23160);
+ rule__Property__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11354:1: rule__Property__Group_0__1 : rule__Property__Group_0__1__Impl ;
+ public final void rule__Property__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11358:1: ( rule__Property__Group_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11359:2: rule__Property__Group_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Property__Group_0__1__Impl_in_rule__Property__Group_0__123190);
+ rule__Property__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0__1"
+
+
+ // $ANTLR start "rule__Property__Group_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11365:1: rule__Property__Group_0__1__Impl : ( ( rule__Property__PropAssignment_0_1 ) ) ;
+ public final void rule__Property__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11369:1: ( ( ( rule__Property__PropAssignment_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11370:1: ( ( rule__Property__PropAssignment_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11370:1: ( ( rule__Property__PropAssignment_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11371:1: ( rule__Property__PropAssignment_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getPropAssignment_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11372:1: ( rule__Property__PropAssignment_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11372:2: rule__Property__PropAssignment_0_1
+ {
+ pushFollow(FOLLOW_rule__Property__PropAssignment_0_1_in_rule__Property__Group_0__1__Impl23217);
+ rule__Property__PropAssignment_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getPropAssignment_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11386:1: rule__Property__Group_0_0__0 : rule__Property__Group_0_0__0__Impl ;
+ public final void rule__Property__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11390:1: ( rule__Property__Group_0_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11391:2: rule__Property__Group_0_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__Property__Group_0_0__0__Impl_in_rule__Property__Group_0_0__023251);
+ rule__Property__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0_0__0"
+
+
+ // $ANTLR start "rule__Property__Group_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11397:1: rule__Property__Group_0_0__0__Impl : ( ( rule__Property__Group_0_0_0__0 ) ) ;
+ public final void rule__Property__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11401:1: ( ( ( rule__Property__Group_0_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11402:1: ( ( rule__Property__Group_0_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11402:1: ( ( rule__Property__Group_0_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11403:1: ( rule__Property__Group_0_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getGroup_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11404:1: ( rule__Property__Group_0_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11404:2: rule__Property__Group_0_0_0__0
+ {
+ pushFollow(FOLLOW_rule__Property__Group_0_0_0__0_in_rule__Property__Group_0_0__0__Impl23278);
+ rule__Property__Group_0_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getGroup_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_0_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11416:1: rule__Property__Group_0_0_0__0 : rule__Property__Group_0_0_0__0__Impl rule__Property__Group_0_0_0__1 ;
+ public final void rule__Property__Group_0_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11420:1: ( rule__Property__Group_0_0_0__0__Impl rule__Property__Group_0_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11421:2: rule__Property__Group_0_0_0__0__Impl rule__Property__Group_0_0_0__1
+ {
+ pushFollow(FOLLOW_rule__Property__Group_0_0_0__0__Impl_in_rule__Property__Group_0_0_0__023310);
+ rule__Property__Group_0_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Property__Group_0_0_0__1_in_rule__Property__Group_0_0_0__023313);
+ rule__Property__Group_0_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0_0_0__0"
+
+
+ // $ANTLR start "rule__Property__Group_0_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11428:1: rule__Property__Group_0_0_0__0__Impl : ( ruleIdRef ) ;
+ public final void rule__Property__Group_0_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11432:1: ( ( ruleIdRef ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11433:1: ( ruleIdRef )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11433:1: ( ruleIdRef )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11434:1: ruleIdRef
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0());
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_rule__Property__Group_0_0_0__0__Impl23340);
+ ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_0_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11445:1: rule__Property__Group_0_0_0__1 : rule__Property__Group_0_0_0__1__Impl ;
+ public final void rule__Property__Group_0_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11449:1: ( rule__Property__Group_0_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11450:2: rule__Property__Group_0_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Property__Group_0_0_0__1__Impl_in_rule__Property__Group_0_0_0__123369);
+ rule__Property__Group_0_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0_0_0__1"
+
+
+ // $ANTLR start "rule__Property__Group_0_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11456:1: rule__Property__Group_0_0_0__1__Impl : ( ( rule__Property__AccessorAssignment_0_0_0_1 ) ) ;
+ public final void rule__Property__Group_0_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11460:1: ( ( ( rule__Property__AccessorAssignment_0_0_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11461:1: ( ( rule__Property__AccessorAssignment_0_0_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11461:1: ( ( rule__Property__AccessorAssignment_0_0_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11462:1: ( rule__Property__AccessorAssignment_0_0_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getAccessorAssignment_0_0_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11463:1: ( rule__Property__AccessorAssignment_0_0_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11463:2: rule__Property__AccessorAssignment_0_0_0_1
+ {
+ pushFollow(FOLLOW_rule__Property__AccessorAssignment_0_0_0_1_in_rule__Property__Group_0_0_0__1__Impl23396);
+ rule__Property__AccessorAssignment_0_0_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getAccessorAssignment_0_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_0_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11477:1: rule__Property__Group_1__0 : rule__Property__Group_1__0__Impl rule__Property__Group_1__1 ;
+ public final void rule__Property__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11481:1: ( rule__Property__Group_1__0__Impl rule__Property__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11482:2: rule__Property__Group_1__0__Impl rule__Property__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__Property__Group_1__0__Impl_in_rule__Property__Group_1__023430);
+ rule__Property__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Property__Group_1__1_in_rule__Property__Group_1__023433);
+ rule__Property__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1__0"
+
+
+ // $ANTLR start "rule__Property__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11489:1: rule__Property__Group_1__0__Impl : ( ( rule__Property__Group_1_0__0 ) ) ;
+ public final void rule__Property__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11493:1: ( ( ( rule__Property__Group_1_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11494:1: ( ( rule__Property__Group_1_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11494:1: ( ( rule__Property__Group_1_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11495:1: ( rule__Property__Group_1_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getGroup_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11496:1: ( rule__Property__Group_1_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11496:2: rule__Property__Group_1_0__0
+ {
+ pushFollow(FOLLOW_rule__Property__Group_1_0__0_in_rule__Property__Group_1__0__Impl23460);
+ rule__Property__Group_1_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getGroup_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11506:1: rule__Property__Group_1__1 : rule__Property__Group_1__1__Impl rule__Property__Group_1__2 ;
+ public final void rule__Property__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11510:1: ( rule__Property__Group_1__1__Impl rule__Property__Group_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11511:2: rule__Property__Group_1__1__Impl rule__Property__Group_1__2
+ {
+ pushFollow(FOLLOW_rule__Property__Group_1__1__Impl_in_rule__Property__Group_1__123490);
+ rule__Property__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Property__Group_1__2_in_rule__Property__Group_1__123493);
+ rule__Property__Group_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1__1"
+
+
+ // $ANTLR start "rule__Property__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11518:1: rule__Property__Group_1__1__Impl : ( ( rule__Property__IndexAssignment_1_1 ) ) ;
+ public final void rule__Property__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11522:1: ( ( ( rule__Property__IndexAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11523:1: ( ( rule__Property__IndexAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11523:1: ( ( rule__Property__IndexAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11524:1: ( rule__Property__IndexAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getIndexAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11525:1: ( rule__Property__IndexAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11525:2: rule__Property__IndexAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__Property__IndexAssignment_1_1_in_rule__Property__Group_1__1__Impl23520);
+ rule__Property__IndexAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getIndexAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11535:1: rule__Property__Group_1__2 : rule__Property__Group_1__2__Impl ;
+ public final void rule__Property__Group_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11539:1: ( rule__Property__Group_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11540:2: rule__Property__Group_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Property__Group_1__2__Impl_in_rule__Property__Group_1__223550);
+ rule__Property__Group_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1__2"
+
+
+ // $ANTLR start "rule__Property__Group_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11546:1: rule__Property__Group_1__2__Impl : ( RULE_INDEX_END ) ;
+ public final void rule__Property__Group_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11550:1: ( ( RULE_INDEX_END ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11551:1: ( RULE_INDEX_END )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11551:1: ( RULE_INDEX_END )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11552:1: RULE_INDEX_END
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2());
+ }
+ match(input,RULE_INDEX_END,FOLLOW_RULE_INDEX_END_in_rule__Property__Group_1__2__Impl23577); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1__2__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11569:1: rule__Property__Group_1_0__0 : rule__Property__Group_1_0__0__Impl ;
+ public final void rule__Property__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11573:1: ( rule__Property__Group_1_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11574:2: rule__Property__Group_1_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__Property__Group_1_0__0__Impl_in_rule__Property__Group_1_0__023612);
+ rule__Property__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1_0__0"
+
+
+ // $ANTLR start "rule__Property__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11580:1: rule__Property__Group_1_0__0__Impl : ( ( rule__Property__Group_1_0_0__0 ) ) ;
+ public final void rule__Property__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11584:1: ( ( ( rule__Property__Group_1_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11585:1: ( ( rule__Property__Group_1_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11585:1: ( ( rule__Property__Group_1_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11586:1: ( rule__Property__Group_1_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getGroup_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11587:1: ( rule__Property__Group_1_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11587:2: rule__Property__Group_1_0_0__0
+ {
+ pushFollow(FOLLOW_rule__Property__Group_1_0_0__0_in_rule__Property__Group_1_0__0__Impl23639);
+ rule__Property__Group_1_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getGroup_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_1_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11599:1: rule__Property__Group_1_0_0__0 : rule__Property__Group_1_0_0__0__Impl rule__Property__Group_1_0_0__1 ;
+ public final void rule__Property__Group_1_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11603:1: ( rule__Property__Group_1_0_0__0__Impl rule__Property__Group_1_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11604:2: rule__Property__Group_1_0_0__0__Impl rule__Property__Group_1_0_0__1
+ {
+ pushFollow(FOLLOW_rule__Property__Group_1_0_0__0__Impl_in_rule__Property__Group_1_0_0__023671);
+ rule__Property__Group_1_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Property__Group_1_0_0__1_in_rule__Property__Group_1_0_0__023674);
+ rule__Property__Group_1_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1_0_0__0"
+
+
+ // $ANTLR start "rule__Property__Group_1_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11611:1: rule__Property__Group_1_0_0__0__Impl : ( ruleIdRef ) ;
+ public final void rule__Property__Group_1_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11615:1: ( ( ruleIdRef ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11616:1: ( ruleIdRef )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11616:1: ( ruleIdRef )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11617:1: ruleIdRef
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0());
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_rule__Property__Group_1_0_0__0__Impl23701);
+ ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__Property__Group_1_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11628:1: rule__Property__Group_1_0_0__1 : rule__Property__Group_1_0_0__1__Impl ;
+ public final void rule__Property__Group_1_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11632:1: ( rule__Property__Group_1_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11633:2: rule__Property__Group_1_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Property__Group_1_0_0__1__Impl_in_rule__Property__Group_1_0_0__123730);
+ rule__Property__Group_1_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1_0_0__1"
+
+
+ // $ANTLR start "rule__Property__Group_1_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11639:1: rule__Property__Group_1_0_0__1__Impl : ( RULE_INDEX_START ) ;
+ public final void rule__Property__Group_1_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11643:1: ( ( RULE_INDEX_START ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11644:1: ( RULE_INDEX_START )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11644:1: ( RULE_INDEX_START )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11645:1: RULE_INDEX_START
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1());
+ }
+ match(input,RULE_INDEX_START,FOLLOW_RULE_INDEX_START_in_rule__Property__Group_1_0_0__1__Impl23757); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__Group_1_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__Variable__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11660:1: rule__Variable__Group_1__0 : rule__Variable__Group_1__0__Impl rule__Variable__Group_1__1 ;
+ public final void rule__Variable__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11664:1: ( rule__Variable__Group_1__0__Impl rule__Variable__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11665:2: rule__Variable__Group_1__0__Impl rule__Variable__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1__0__Impl_in_rule__Variable__Group_1__023790);
+ rule__Variable__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Variable__Group_1__1_in_rule__Variable__Group_1__023793);
+ rule__Variable__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1__0"
+
+
+ // $ANTLR start "rule__Variable__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11672:1: rule__Variable__Group_1__0__Impl : ( ( rule__Variable__Alternatives_1_0 ) ) ;
+ public final void rule__Variable__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11676:1: ( ( ( rule__Variable__Alternatives_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11677:1: ( ( rule__Variable__Alternatives_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11677:1: ( ( rule__Variable__Alternatives_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11678:1: ( rule__Variable__Alternatives_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getAlternatives_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11679:1: ( rule__Variable__Alternatives_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11679:2: rule__Variable__Alternatives_1_0
+ {
+ pushFollow(FOLLOW_rule__Variable__Alternatives_1_0_in_rule__Variable__Group_1__0__Impl23820);
+ rule__Variable__Alternatives_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getAlternatives_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__Variable__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11689:1: rule__Variable__Group_1__1 : rule__Variable__Group_1__1__Impl rule__Variable__Group_1__2 ;
+ public final void rule__Variable__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11693:1: ( rule__Variable__Group_1__1__Impl rule__Variable__Group_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11694:2: rule__Variable__Group_1__1__Impl rule__Variable__Group_1__2
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1__1__Impl_in_rule__Variable__Group_1__123850);
+ rule__Variable__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Variable__Group_1__2_in_rule__Variable__Group_1__123853);
+ rule__Variable__Group_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1__1"
+
+
+ // $ANTLR start "rule__Variable__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11701:1: rule__Variable__Group_1__1__Impl : ( ruleId ) ;
+ public final void rule__Variable__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11705:1: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11706:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11706:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11707:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getIdParserRuleCall_1_1());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__Variable__Group_1__1__Impl23880);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getIdParserRuleCall_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__Variable__Group_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11718:1: rule__Variable__Group_1__2 : rule__Variable__Group_1__2__Impl ;
+ public final void rule__Variable__Group_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11722:1: ( rule__Variable__Group_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11723:2: rule__Variable__Group_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1__2__Impl_in_rule__Variable__Group_1__223909);
+ rule__Variable__Group_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1__2"
+
+
+ // $ANTLR start "rule__Variable__Group_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11729:1: rule__Variable__Group_1__2__Impl : ( ( rule__Variable__Group_1_2__0 )* ) ;
+ public final void rule__Variable__Group_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11733:1: ( ( ( rule__Variable__Group_1_2__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11734:1: ( ( rule__Variable__Group_1_2__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11734:1: ( ( rule__Variable__Group_1_2__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11735:1: ( rule__Variable__Group_1_2__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getGroup_1_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11736:1: ( rule__Variable__Group_1_2__0 )*
+ loop89:
+ do {
+ int alt89=2;
+ int LA89_0 = input.LA(1);
+
+ if ( (LA89_0==RULE_DOT) ) {
+ alt89=1;
+ }
+
+
+ switch (alt89) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11736:2: rule__Variable__Group_1_2__0
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1_2__0_in_rule__Variable__Group_1__2__Impl23936);
+ rule__Variable__Group_1_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop89;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getGroup_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1__2__Impl"
+
+
+ // $ANTLR start "rule__Variable__Group_1_0_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11752:1: rule__Variable__Group_1_0_1__0 : rule__Variable__Group_1_0_1__0__Impl rule__Variable__Group_1_0_1__1 ;
+ public final void rule__Variable__Group_1_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11756:1: ( rule__Variable__Group_1_0_1__0__Impl rule__Variable__Group_1_0_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11757:2: rule__Variable__Group_1_0_1__0__Impl rule__Variable__Group_1_0_1__1
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1_0_1__0__Impl_in_rule__Variable__Group_1_0_1__023973);
+ rule__Variable__Group_1_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Variable__Group_1_0_1__1_in_rule__Variable__Group_1_0_1__023976);
+ rule__Variable__Group_1_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1_0_1__0"
+
+
+ // $ANTLR start "rule__Variable__Group_1_0_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11764:1: rule__Variable__Group_1_0_1__0__Impl : ( RULE_THIS ) ;
+ public final void rule__Variable__Group_1_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11768:1: ( ( RULE_THIS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11769:1: ( RULE_THIS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11769:1: ( RULE_THIS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11770:1: RULE_THIS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getTHISTerminalRuleCall_1_0_1_0());
+ }
+ match(input,RULE_THIS,FOLLOW_RULE_THIS_in_rule__Variable__Group_1_0_1__0__Impl24003); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getTHISTerminalRuleCall_1_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__Variable__Group_1_0_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11781:1: rule__Variable__Group_1_0_1__1 : rule__Variable__Group_1_0_1__1__Impl ;
+ public final void rule__Variable__Group_1_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11785:1: ( rule__Variable__Group_1_0_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11786:2: rule__Variable__Group_1_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1_0_1__1__Impl_in_rule__Variable__Group_1_0_1__124032);
+ rule__Variable__Group_1_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1_0_1__1"
+
+
+ // $ANTLR start "rule__Variable__Group_1_0_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11792:1: rule__Variable__Group_1_0_1__1__Impl : ( RULE_DOT ) ;
+ public final void rule__Variable__Group_1_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11796:1: ( ( RULE_DOT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11797:1: ( RULE_DOT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11797:1: ( RULE_DOT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11798:1: RULE_DOT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_0_1_1());
+ }
+ match(input,RULE_DOT,FOLLOW_RULE_DOT_in_rule__Variable__Group_1_0_1__1__Impl24059); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__Variable__Group_1_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11813:1: rule__Variable__Group_1_2__0 : rule__Variable__Group_1_2__0__Impl rule__Variable__Group_1_2__1 ;
+ public final void rule__Variable__Group_1_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11817:1: ( rule__Variable__Group_1_2__0__Impl rule__Variable__Group_1_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11818:2: rule__Variable__Group_1_2__0__Impl rule__Variable__Group_1_2__1
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1_2__0__Impl_in_rule__Variable__Group_1_2__024092);
+ rule__Variable__Group_1_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Variable__Group_1_2__1_in_rule__Variable__Group_1_2__024095);
+ rule__Variable__Group_1_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1_2__0"
+
+
+ // $ANTLR start "rule__Variable__Group_1_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11825:1: rule__Variable__Group_1_2__0__Impl : ( RULE_DOT ) ;
+ public final void rule__Variable__Group_1_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11829:1: ( ( RULE_DOT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11830:1: ( RULE_DOT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11830:1: ( RULE_DOT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11831:1: RULE_DOT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0());
+ }
+ match(input,RULE_DOT,FOLLOW_RULE_DOT_in_rule__Variable__Group_1_2__0__Impl24122); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1_2__0__Impl"
+
+
+ // $ANTLR start "rule__Variable__Group_1_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11842:1: rule__Variable__Group_1_2__1 : rule__Variable__Group_1_2__1__Impl ;
+ public final void rule__Variable__Group_1_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11846:1: ( rule__Variable__Group_1_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11847:2: rule__Variable__Group_1_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Variable__Group_1_2__1__Impl_in_rule__Variable__Group_1_2__124151);
+ rule__Variable__Group_1_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1_2__1"
+
+
+ // $ANTLR start "rule__Variable__Group_1_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11853:1: rule__Variable__Group_1_2__1__Impl : ( ( rule__Variable__PropsAssignment_1_2_1 ) ) ;
+ public final void rule__Variable__Group_1_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11857:1: ( ( ( rule__Variable__PropsAssignment_1_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11858:1: ( ( rule__Variable__PropsAssignment_1_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11858:1: ( ( rule__Variable__PropsAssignment_1_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11859:1: ( rule__Variable__PropsAssignment_1_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getPropsAssignment_1_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11860:1: ( rule__Variable__PropsAssignment_1_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11860:2: rule__Variable__PropsAssignment_1_2_1
+ {
+ pushFollow(FOLLOW_rule__Variable__PropsAssignment_1_2_1_in_rule__Variable__Group_1_2__1__Impl24178);
+ rule__Variable__PropsAssignment_1_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getPropsAssignment_1_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__Group_1_2__1__Impl"
+
+
+ // $ANTLR start "rule__AssignableArray__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11874:1: rule__AssignableArray__Group__0 : rule__AssignableArray__Group__0__Impl rule__AssignableArray__Group__1 ;
+ public final void rule__AssignableArray__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11878:1: ( rule__AssignableArray__Group__0__Impl rule__AssignableArray__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11879:2: rule__AssignableArray__Group__0__Impl rule__AssignableArray__Group__1
+ {
+ pushFollow(FOLLOW_rule__AssignableArray__Group__0__Impl_in_rule__AssignableArray__Group__024212);
+ rule__AssignableArray__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignableArray__Group__1_in_rule__AssignableArray__Group__024215);
+ rule__AssignableArray__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArray__Group__0"
+
+
+ // $ANTLR start "rule__AssignableArray__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11886:1: rule__AssignableArray__Group__0__Impl : ( ( RULE_LBRACKET ) ) ;
+ public final void rule__AssignableArray__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11890:1: ( ( ( RULE_LBRACKET ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11891:1: ( ( RULE_LBRACKET ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11891:1: ( ( RULE_LBRACKET ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11892:1: ( RULE_LBRACKET )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11893:1: ( RULE_LBRACKET )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11893:3: RULE_LBRACKET
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_rule__AssignableArray__Group__0__Impl24243); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArray__Group__0__Impl"
+
+
+ // $ANTLR start "rule__AssignableArray__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11903:1: rule__AssignableArray__Group__1 : rule__AssignableArray__Group__1__Impl rule__AssignableArray__Group__2 ;
+ public final void rule__AssignableArray__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11907:1: ( rule__AssignableArray__Group__1__Impl rule__AssignableArray__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11908:2: rule__AssignableArray__Group__1__Impl rule__AssignableArray__Group__2
+ {
+ pushFollow(FOLLOW_rule__AssignableArray__Group__1__Impl_in_rule__AssignableArray__Group__124273);
+ rule__AssignableArray__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignableArray__Group__2_in_rule__AssignableArray__Group__124276);
+ rule__AssignableArray__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArray__Group__1"
+
+
+ // $ANTLR start "rule__AssignableArray__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11915:1: rule__AssignableArray__Group__1__Impl : ( ruleAssignableArgList ) ;
+ public final void rule__AssignableArray__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11919:1: ( ( ruleAssignableArgList ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11920:1: ( ruleAssignableArgList )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11920:1: ( ruleAssignableArgList )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11921:1: ruleAssignableArgList
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleAssignableArgList_in_rule__AssignableArray__Group__1__Impl24303);
+ ruleAssignableArgList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArray__Group__1__Impl"
+
+
+ // $ANTLR start "rule__AssignableArray__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11932:1: rule__AssignableArray__Group__2 : rule__AssignableArray__Group__2__Impl ;
+ public final void rule__AssignableArray__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11936:1: ( rule__AssignableArray__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11937:2: rule__AssignableArray__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__AssignableArray__Group__2__Impl_in_rule__AssignableArray__Group__224332);
+ rule__AssignableArray__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArray__Group__2"
+
+
+ // $ANTLR start "rule__AssignableArray__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11943:1: rule__AssignableArray__Group__2__Impl : ( RULE_RBRACKET ) ;
+ public final void rule__AssignableArray__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11947:1: ( ( RULE_RBRACKET ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11948:1: ( RULE_RBRACKET )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11948:1: ( RULE_RBRACKET )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11949:1: RULE_RBRACKET
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2());
+ }
+ match(input,RULE_RBRACKET,FOLLOW_RULE_RBRACKET_in_rule__AssignableArray__Group__2__Impl24359); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArray__Group__2__Impl"
+
+
+ // $ANTLR start "rule__AssignableArgList__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11966:1: rule__AssignableArgList__Group__0 : rule__AssignableArgList__Group__0__Impl rule__AssignableArgList__Group__1 ;
+ public final void rule__AssignableArgList__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11970:1: ( rule__AssignableArgList__Group__0__Impl rule__AssignableArgList__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11971:2: rule__AssignableArgList__Group__0__Impl rule__AssignableArgList__Group__1
+ {
+ pushFollow(FOLLOW_rule__AssignableArgList__Group__0__Impl_in_rule__AssignableArgList__Group__024394);
+ rule__AssignableArgList__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignableArgList__Group__1_in_rule__AssignableArgList__Group__024397);
+ rule__AssignableArgList__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__Group__0"
+
+
+ // $ANTLR start "rule__AssignableArgList__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11978:1: rule__AssignableArgList__Group__0__Impl : ( ( rule__AssignableArgList__ArgsAssignment_0 ) ) ;
+ public final void rule__AssignableArgList__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11982:1: ( ( ( rule__AssignableArgList__ArgsAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11983:1: ( ( rule__AssignableArgList__ArgsAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11983:1: ( ( rule__AssignableArgList__ArgsAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11984:1: ( rule__AssignableArgList__ArgsAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgListAccess().getArgsAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11985:1: ( rule__AssignableArgList__ArgsAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11985:2: rule__AssignableArgList__ArgsAssignment_0
+ {
+ pushFollow(FOLLOW_rule__AssignableArgList__ArgsAssignment_0_in_rule__AssignableArgList__Group__0__Impl24424);
+ rule__AssignableArgList__ArgsAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgListAccess().getArgsAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__Group__0__Impl"
+
+
+ // $ANTLR start "rule__AssignableArgList__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11995:1: rule__AssignableArgList__Group__1 : rule__AssignableArgList__Group__1__Impl ;
+ public final void rule__AssignableArgList__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:11999:1: ( rule__AssignableArgList__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12000:2: rule__AssignableArgList__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__AssignableArgList__Group__1__Impl_in_rule__AssignableArgList__Group__124454);
+ rule__AssignableArgList__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__Group__1"
+
+
+ // $ANTLR start "rule__AssignableArgList__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12006:1: rule__AssignableArgList__Group__1__Impl : ( ( rule__AssignableArgList__Group_1__0 )* ) ;
+ public final void rule__AssignableArgList__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12010:1: ( ( ( rule__AssignableArgList__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12011:1: ( ( rule__AssignableArgList__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12011:1: ( ( rule__AssignableArgList__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12012:1: ( rule__AssignableArgList__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgListAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12013:1: ( rule__AssignableArgList__Group_1__0 )*
+ loop90:
+ do {
+ int alt90=2;
+ int LA90_0 = input.LA(1);
+
+ if ( (LA90_0==RULE_COMMA) ) {
+ alt90=1;
+ }
+
+
+ switch (alt90) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12013:2: rule__AssignableArgList__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__AssignableArgList__Group_1__0_in_rule__AssignableArgList__Group__1__Impl24481);
+ rule__AssignableArgList__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop90;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgListAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__Group__1__Impl"
+
+
+ // $ANTLR start "rule__AssignableArgList__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12027:1: rule__AssignableArgList__Group_1__0 : rule__AssignableArgList__Group_1__0__Impl rule__AssignableArgList__Group_1__1 ;
+ public final void rule__AssignableArgList__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12031:1: ( rule__AssignableArgList__Group_1__0__Impl rule__AssignableArgList__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12032:2: rule__AssignableArgList__Group_1__0__Impl rule__AssignableArgList__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__AssignableArgList__Group_1__0__Impl_in_rule__AssignableArgList__Group_1__024516);
+ rule__AssignableArgList__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignableArgList__Group_1__1_in_rule__AssignableArgList__Group_1__024519);
+ rule__AssignableArgList__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__Group_1__0"
+
+
+ // $ANTLR start "rule__AssignableArgList__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12039:1: rule__AssignableArgList__Group_1__0__Impl : ( RULE_COMMA ) ;
+ public final void rule__AssignableArgList__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12043:1: ( ( RULE_COMMA ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12044:1: ( RULE_COMMA )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12044:1: ( RULE_COMMA )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12045:1: RULE_COMMA
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0());
+ }
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__AssignableArgList__Group_1__0__Impl24546); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__AssignableArgList__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12056:1: rule__AssignableArgList__Group_1__1 : rule__AssignableArgList__Group_1__1__Impl ;
+ public final void rule__AssignableArgList__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12060:1: ( rule__AssignableArgList__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12061:2: rule__AssignableArgList__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__AssignableArgList__Group_1__1__Impl_in_rule__AssignableArgList__Group_1__124575);
+ rule__AssignableArgList__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__Group_1__1"
+
+
+ // $ANTLR start "rule__AssignableArgList__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12067:1: rule__AssignableArgList__Group_1__1__Impl : ( ( rule__AssignableArgList__ArgsAssignment_1_1 ) ) ;
+ public final void rule__AssignableArgList__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12071:1: ( ( ( rule__AssignableArgList__ArgsAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12072:1: ( ( rule__AssignableArgList__ArgsAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12072:1: ( ( rule__AssignableArgList__ArgsAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12073:1: ( rule__AssignableArgList__ArgsAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgListAccess().getArgsAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12074:1: ( rule__AssignableArgList__ArgsAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12074:2: rule__AssignableArgList__ArgsAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__AssignableArgList__ArgsAssignment_1_1_in_rule__AssignableArgList__Group_1__1__Impl24602);
+ rule__AssignableArgList__ArgsAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgListAccess().getArgsAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__AssignableArg__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12088:1: rule__AssignableArg__Group__0 : rule__AssignableArg__Group__0__Impl rule__AssignableArg__Group__1 ;
+ public final void rule__AssignableArg__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12092:1: ( rule__AssignableArg__Group__0__Impl rule__AssignableArg__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12093:2: rule__AssignableArg__Group__0__Impl rule__AssignableArg__Group__1
+ {
+ pushFollow(FOLLOW_rule__AssignableArg__Group__0__Impl_in_rule__AssignableArg__Group__024636);
+ rule__AssignableArg__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__AssignableArg__Group__1_in_rule__AssignableArg__Group__024639);
+ rule__AssignableArg__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArg__Group__0"
+
+
+ // $ANTLR start "rule__AssignableArg__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12100:1: rule__AssignableArg__Group__0__Impl : ( ( rule__AssignableArg__ArgAssignment_0 ) ) ;
+ public final void rule__AssignableArg__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12104:1: ( ( ( rule__AssignableArg__ArgAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12105:1: ( ( rule__AssignableArg__ArgAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12105:1: ( ( rule__AssignableArg__ArgAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12106:1: ( rule__AssignableArg__ArgAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgAccess().getArgAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12107:1: ( rule__AssignableArg__ArgAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12107:2: rule__AssignableArg__ArgAssignment_0
+ {
+ pushFollow(FOLLOW_rule__AssignableArg__ArgAssignment_0_in_rule__AssignableArg__Group__0__Impl24666);
+ rule__AssignableArg__ArgAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgAccess().getArgAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArg__Group__0__Impl"
+
+
+ // $ANTLR start "rule__AssignableArg__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12117:1: rule__AssignableArg__Group__1 : rule__AssignableArg__Group__1__Impl ;
+ public final void rule__AssignableArg__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12121:1: ( rule__AssignableArg__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12122:2: rule__AssignableArg__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__AssignableArg__Group__1__Impl_in_rule__AssignableArg__Group__124696);
+ rule__AssignableArg__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArg__Group__1"
+
+
+ // $ANTLR start "rule__AssignableArg__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12128:1: rule__AssignableArg__Group__1__Impl : ( ( rule__AssignableArg__SplatAssignment_1 )? ) ;
+ public final void rule__AssignableArg__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12132:1: ( ( ( rule__AssignableArg__SplatAssignment_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12133:1: ( ( rule__AssignableArg__SplatAssignment_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12133:1: ( ( rule__AssignableArg__SplatAssignment_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12134:1: ( rule__AssignableArg__SplatAssignment_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgAccess().getSplatAssignment_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12135:1: ( rule__AssignableArg__SplatAssignment_1 )?
+ int alt91=2;
+ int LA91_0 = input.LA(1);
+
+ if ( (LA91_0==RULE_ELLIPSIS) ) {
+ alt91=1;
+ }
+ switch (alt91) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12135:2: rule__AssignableArg__SplatAssignment_1
+ {
+ pushFollow(FOLLOW_rule__AssignableArg__SplatAssignment_1_in_rule__AssignableArg__Group__1__Impl24723);
+ rule__AssignableArg__SplatAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgAccess().getSplatAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArg__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Arg__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12149:1: rule__Arg__Group__0 : rule__Arg__Group__0__Impl rule__Arg__Group__1 ;
+ public final void rule__Arg__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12153:1: ( rule__Arg__Group__0__Impl rule__Arg__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12154:2: rule__Arg__Group__0__Impl rule__Arg__Group__1
+ {
+ pushFollow(FOLLOW_rule__Arg__Group__0__Impl_in_rule__Arg__Group__024758);
+ rule__Arg__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Arg__Group__1_in_rule__Arg__Group__024761);
+ rule__Arg__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Arg__Group__0"
+
+
+ // $ANTLR start "rule__Arg__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12161:1: rule__Arg__Group__0__Impl : ( ( rule__Arg__ExpAssignment_0 ) ) ;
+ public final void rule__Arg__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12165:1: ( ( ( rule__Arg__ExpAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12166:1: ( ( rule__Arg__ExpAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12166:1: ( ( rule__Arg__ExpAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12167:1: ( rule__Arg__ExpAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgAccess().getExpAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12168:1: ( rule__Arg__ExpAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12168:2: rule__Arg__ExpAssignment_0
+ {
+ pushFollow(FOLLOW_rule__Arg__ExpAssignment_0_in_rule__Arg__Group__0__Impl24788);
+ rule__Arg__ExpAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgAccess().getExpAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Arg__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Arg__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12178:1: rule__Arg__Group__1 : rule__Arg__Group__1__Impl ;
+ public final void rule__Arg__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12182:1: ( rule__Arg__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12183:2: rule__Arg__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Arg__Group__1__Impl_in_rule__Arg__Group__124818);
+ rule__Arg__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Arg__Group__1"
+
+
+ // $ANTLR start "rule__Arg__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12189:1: rule__Arg__Group__1__Impl : ( ( rule__Arg__SplatAssignment_1 )? ) ;
+ public final void rule__Arg__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12193:1: ( ( ( rule__Arg__SplatAssignment_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12194:1: ( ( rule__Arg__SplatAssignment_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12194:1: ( ( rule__Arg__SplatAssignment_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12195:1: ( rule__Arg__SplatAssignment_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgAccess().getSplatAssignment_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12196:1: ( rule__Arg__SplatAssignment_1 )?
+ int alt92=2;
+ int LA92_0 = input.LA(1);
+
+ if ( (LA92_0==RULE_ELLIPSIS) ) {
+ alt92=1;
+ }
+ switch (alt92) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12196:2: rule__Arg__SplatAssignment_1
+ {
+ pushFollow(FOLLOW_rule__Arg__SplatAssignment_1_in_rule__Arg__Group__1__Impl24845);
+ rule__Arg__SplatAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgAccess().getSplatAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Arg__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ArgLine__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12210:1: rule__ArgLine__Group__0 : rule__ArgLine__Group__0__Impl rule__ArgLine__Group__1 ;
+ public final void rule__ArgLine__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12214:1: ( rule__ArgLine__Group__0__Impl rule__ArgLine__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12215:2: rule__ArgLine__Group__0__Impl rule__ArgLine__Group__1
+ {
+ pushFollow(FOLLOW_rule__ArgLine__Group__0__Impl_in_rule__ArgLine__Group__024880);
+ rule__ArgLine__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ArgLine__Group__1_in_rule__ArgLine__Group__024883);
+ rule__ArgLine__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group__0"
+
+
+ // $ANTLR start "rule__ArgLine__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12222:1: rule__ArgLine__Group__0__Impl : ( ( rule__ArgLine__HeadAssignment_0 ) ) ;
+ public final void rule__ArgLine__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12226:1: ( ( ( rule__ArgLine__HeadAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12227:1: ( ( rule__ArgLine__HeadAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12227:1: ( ( rule__ArgLine__HeadAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12228:1: ( rule__ArgLine__HeadAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgLineAccess().getHeadAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12229:1: ( rule__ArgLine__HeadAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12229:2: rule__ArgLine__HeadAssignment_0
+ {
+ pushFollow(FOLLOW_rule__ArgLine__HeadAssignment_0_in_rule__ArgLine__Group__0__Impl24910);
+ rule__ArgLine__HeadAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgLineAccess().getHeadAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ArgLine__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12239:1: rule__ArgLine__Group__1 : rule__ArgLine__Group__1__Impl rule__ArgLine__Group__2 ;
+ public final void rule__ArgLine__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12243:1: ( rule__ArgLine__Group__1__Impl rule__ArgLine__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12244:2: rule__ArgLine__Group__1__Impl rule__ArgLine__Group__2
+ {
+ pushFollow(FOLLOW_rule__ArgLine__Group__1__Impl_in_rule__ArgLine__Group__124940);
+ rule__ArgLine__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ArgLine__Group__2_in_rule__ArgLine__Group__124943);
+ rule__ArgLine__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group__1"
+
+
+ // $ANTLR start "rule__ArgLine__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12251:1: rule__ArgLine__Group__1__Impl : ( ( rule__ArgLine__Group_1__0 )* ) ;
+ public final void rule__ArgLine__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12255:1: ( ( ( rule__ArgLine__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12256:1: ( ( rule__ArgLine__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12256:1: ( ( rule__ArgLine__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12257:1: ( rule__ArgLine__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgLineAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12258:1: ( rule__ArgLine__Group_1__0 )*
+ loop93:
+ do {
+ int alt93=2;
+ int LA93_0 = input.LA(1);
+
+ if ( (LA93_0==RULE_COMMA) ) {
+ int LA93_1 = input.LA(2);
+
+ if ( ((LA93_1>=RULE_PLUS && LA93_1<=RULE_MINUS_MINUS)||(LA93_1>=RULE_AT_SIGIL && LA93_1<=RULE_BOUND_FUNC_ARROW)||LA93_1==RULE_PARAM_START||(LA93_1>=RULE_FOR && LA93_1<=RULE_WHILE)||LA93_1==RULE_UNTIL||LA93_1==RULE_LBRACKET||LA93_1==RULE_SUPER||(LA93_1>=RULE_THIS && LA93_1<=RULE_TRY)||LA93_1==RULE_SWITCH||LA93_1==RULE_LCURLY||(LA93_1>=RULE_NUMBER && LA93_1<=RULE_REGEX)||LA93_1==RULE_LPAREN||(LA93_1>=RULE_IF && LA93_1<=RULE_IDENTIFIER)) ) {
+ alt93=1;
+ }
+
+
+ }
+
+
+ switch (alt93) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12258:2: rule__ArgLine__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__ArgLine__Group_1__0_in_rule__ArgLine__Group__1__Impl24970);
+ rule__ArgLine__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop93;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgLineAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ArgLine__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12268:1: rule__ArgLine__Group__2 : rule__ArgLine__Group__2__Impl ;
+ public final void rule__ArgLine__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12272:1: ( rule__ArgLine__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12273:2: rule__ArgLine__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ArgLine__Group__2__Impl_in_rule__ArgLine__Group__225001);
+ rule__ArgLine__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group__2"
+
+
+ // $ANTLR start "rule__ArgLine__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12279:1: rule__ArgLine__Group__2__Impl : ( ( RULE_COMMA )? ) ;
+ public final void rule__ArgLine__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12283:1: ( ( ( RULE_COMMA )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12284:1: ( ( RULE_COMMA )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12284:1: ( ( RULE_COMMA )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12285:1: ( RULE_COMMA )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12286:1: ( RULE_COMMA )?
+ int alt94=2;
+ int LA94_0 = input.LA(1);
+
+ if ( (LA94_0==RULE_COMMA) ) {
+ alt94=1;
+ }
+ switch (alt94) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12286:3: RULE_COMMA
+ {
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__ArgLine__Group__2__Impl25029); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group__2__Impl"
+
+
+ // $ANTLR start "rule__ArgLine__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12302:1: rule__ArgLine__Group_1__0 : rule__ArgLine__Group_1__0__Impl rule__ArgLine__Group_1__1 ;
+ public final void rule__ArgLine__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12306:1: ( rule__ArgLine__Group_1__0__Impl rule__ArgLine__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12307:2: rule__ArgLine__Group_1__0__Impl rule__ArgLine__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__ArgLine__Group_1__0__Impl_in_rule__ArgLine__Group_1__025066);
+ rule__ArgLine__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ArgLine__Group_1__1_in_rule__ArgLine__Group_1__025069);
+ rule__ArgLine__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group_1__0"
+
+
+ // $ANTLR start "rule__ArgLine__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12314:1: rule__ArgLine__Group_1__0__Impl : ( RULE_COMMA ) ;
+ public final void rule__ArgLine__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12318:1: ( ( RULE_COMMA ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12319:1: ( RULE_COMMA )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12319:1: ( RULE_COMMA )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12320:1: RULE_COMMA
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0());
+ }
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__ArgLine__Group_1__0__Impl25096); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__ArgLine__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12331:1: rule__ArgLine__Group_1__1 : rule__ArgLine__Group_1__1__Impl ;
+ public final void rule__ArgLine__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12335:1: ( rule__ArgLine__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12336:2: rule__ArgLine__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ArgLine__Group_1__1__Impl_in_rule__ArgLine__Group_1__125125);
+ rule__ArgLine__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group_1__1"
+
+
+ // $ANTLR start "rule__ArgLine__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12342:1: rule__ArgLine__Group_1__1__Impl : ( ( rule__ArgLine__TailAssignment_1_1 ) ) ;
+ public final void rule__ArgLine__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12346:1: ( ( ( rule__ArgLine__TailAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12347:1: ( ( rule__ArgLine__TailAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12347:1: ( ( rule__ArgLine__TailAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12348:1: ( rule__ArgLine__TailAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgLineAccess().getTailAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12349:1: ( rule__ArgLine__TailAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12349:2: rule__ArgLine__TailAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__ArgLine__TailAssignment_1_1_in_rule__ArgLine__Group_1__1__Impl25152);
+ rule__ArgLine__TailAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgLineAccess().getTailAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12363:1: rule__ExplicitArgList__Group__0 : rule__ExplicitArgList__Group__0__Impl rule__ExplicitArgList__Group__1 ;
+ public final void rule__ExplicitArgList__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12367:1: ( rule__ExplicitArgList__Group__0__Impl rule__ExplicitArgList__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12368:2: rule__ExplicitArgList__Group__0__Impl rule__ExplicitArgList__Group__1
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group__0__Impl_in_rule__ExplicitArgList__Group__025186);
+ rule__ExplicitArgList__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group__1_in_rule__ExplicitArgList__Group__025189);
+ rule__ExplicitArgList__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group__0"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12375:1: rule__ExplicitArgList__Group__0__Impl : ( ( rule__ExplicitArgList__LinesAssignment_0 ) ) ;
+ public final void rule__ExplicitArgList__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12379:1: ( ( ( rule__ExplicitArgList__LinesAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12380:1: ( ( rule__ExplicitArgList__LinesAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12380:1: ( ( rule__ExplicitArgList__LinesAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12381:1: ( rule__ExplicitArgList__LinesAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getLinesAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12382:1: ( rule__ExplicitArgList__LinesAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12382:2: rule__ExplicitArgList__LinesAssignment_0
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__LinesAssignment_0_in_rule__ExplicitArgList__Group__0__Impl25216);
+ rule__ExplicitArgList__LinesAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getLinesAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12392:1: rule__ExplicitArgList__Group__1 : rule__ExplicitArgList__Group__1__Impl ;
+ public final void rule__ExplicitArgList__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12396:1: ( rule__ExplicitArgList__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12397:2: rule__ExplicitArgList__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group__1__Impl_in_rule__ExplicitArgList__Group__125246);
+ rule__ExplicitArgList__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group__1"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12403:1: rule__ExplicitArgList__Group__1__Impl : ( ( rule__ExplicitArgList__Alternatives_1 )* ) ;
+ public final void rule__ExplicitArgList__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12407:1: ( ( ( rule__ExplicitArgList__Alternatives_1 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12408:1: ( ( rule__ExplicitArgList__Alternatives_1 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12408:1: ( ( rule__ExplicitArgList__Alternatives_1 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12409:1: ( rule__ExplicitArgList__Alternatives_1 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getAlternatives_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12410:1: ( rule__ExplicitArgList__Alternatives_1 )*
+ loop95:
+ do {
+ int alt95=2;
+ int LA95_0 = input.LA(1);
+
+ if ( (LA95_0==RULE_TERMINATOR||LA95_0==RULE_INDENT) ) {
+ alt95=1;
+ }
+
+
+ switch (alt95) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12410:2: rule__ExplicitArgList__Alternatives_1
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Alternatives_1_in_rule__ExplicitArgList__Group__1__Impl25273);
+ rule__ExplicitArgList__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop95;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12424:1: rule__ExplicitArgList__Group_1_0__0 : rule__ExplicitArgList__Group_1_0__0__Impl rule__ExplicitArgList__Group_1_0__1 ;
+ public final void rule__ExplicitArgList__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12428:1: ( rule__ExplicitArgList__Group_1_0__0__Impl rule__ExplicitArgList__Group_1_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12429:2: rule__ExplicitArgList__Group_1_0__0__Impl rule__ExplicitArgList__Group_1_0__1
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_0__0__Impl_in_rule__ExplicitArgList__Group_1_0__025308);
+ rule__ExplicitArgList__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_0__1_in_rule__ExplicitArgList__Group_1_0__025311);
+ rule__ExplicitArgList__Group_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_0__0"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12436:1: rule__ExplicitArgList__Group_1_0__0__Impl : ( RULE_TERMINATOR ) ;
+ public final void rule__ExplicitArgList__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12440:1: ( ( RULE_TERMINATOR ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12441:1: ( RULE_TERMINATOR )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12441:1: ( RULE_TERMINATOR )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12442:1: RULE_TERMINATOR
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0());
+ }
+ match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_rule__ExplicitArgList__Group_1_0__0__Impl25338); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12453:1: rule__ExplicitArgList__Group_1_0__1 : rule__ExplicitArgList__Group_1_0__1__Impl ;
+ public final void rule__ExplicitArgList__Group_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12457:1: ( rule__ExplicitArgList__Group_1_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12458:2: rule__ExplicitArgList__Group_1_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_0__1__Impl_in_rule__ExplicitArgList__Group_1_0__125367);
+ rule__ExplicitArgList__Group_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_0__1"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12464:1: rule__ExplicitArgList__Group_1_0__1__Impl : ( ( rule__ExplicitArgList__LinesAssignment_1_0_1 ) ) ;
+ public final void rule__ExplicitArgList__Group_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12468:1: ( ( ( rule__ExplicitArgList__LinesAssignment_1_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12469:1: ( ( rule__ExplicitArgList__LinesAssignment_1_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12469:1: ( ( rule__ExplicitArgList__LinesAssignment_1_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12470:1: ( rule__ExplicitArgList__LinesAssignment_1_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12471:1: ( rule__ExplicitArgList__LinesAssignment_1_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12471:2: rule__ExplicitArgList__LinesAssignment_1_0_1
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__LinesAssignment_1_0_1_in_rule__ExplicitArgList__Group_1_0__1__Impl25394);
+ rule__ExplicitArgList__LinesAssignment_1_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12485:1: rule__ExplicitArgList__Group_1_1__0 : rule__ExplicitArgList__Group_1_1__0__Impl rule__ExplicitArgList__Group_1_1__1 ;
+ public final void rule__ExplicitArgList__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12489:1: ( rule__ExplicitArgList__Group_1_1__0__Impl rule__ExplicitArgList__Group_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12490:2: rule__ExplicitArgList__Group_1_1__0__Impl rule__ExplicitArgList__Group_1_1__1
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_1__0__Impl_in_rule__ExplicitArgList__Group_1_1__025428);
+ rule__ExplicitArgList__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_1__1_in_rule__ExplicitArgList__Group_1_1__025431);
+ rule__ExplicitArgList__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_1__0"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12497:1: rule__ExplicitArgList__Group_1_1__0__Impl : ( RULE_INDENT ) ;
+ public final void rule__ExplicitArgList__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12501:1: ( ( RULE_INDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12502:1: ( RULE_INDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12502:1: ( RULE_INDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12503:1: RULE_INDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rule__ExplicitArgList__Group_1_1__0__Impl25458); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12514:1: rule__ExplicitArgList__Group_1_1__1 : rule__ExplicitArgList__Group_1_1__1__Impl rule__ExplicitArgList__Group_1_1__2 ;
+ public final void rule__ExplicitArgList__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12518:1: ( rule__ExplicitArgList__Group_1_1__1__Impl rule__ExplicitArgList__Group_1_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12519:2: rule__ExplicitArgList__Group_1_1__1__Impl rule__ExplicitArgList__Group_1_1__2
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_1__1__Impl_in_rule__ExplicitArgList__Group_1_1__125487);
+ rule__ExplicitArgList__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_1__2_in_rule__ExplicitArgList__Group_1_1__125490);
+ rule__ExplicitArgList__Group_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_1__1"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12526:1: rule__ExplicitArgList__Group_1_1__1__Impl : ( ( rule__ExplicitArgList__LinesAssignment_1_1_1 ) ) ;
+ public final void rule__ExplicitArgList__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12530:1: ( ( ( rule__ExplicitArgList__LinesAssignment_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12531:1: ( ( rule__ExplicitArgList__LinesAssignment_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12531:1: ( ( rule__ExplicitArgList__LinesAssignment_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12532:1: ( rule__ExplicitArgList__LinesAssignment_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12533:1: ( rule__ExplicitArgList__LinesAssignment_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12533:2: rule__ExplicitArgList__LinesAssignment_1_1_1
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__LinesAssignment_1_1_1_in_rule__ExplicitArgList__Group_1_1__1__Impl25517);
+ rule__ExplicitArgList__LinesAssignment_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12543:1: rule__ExplicitArgList__Group_1_1__2 : rule__ExplicitArgList__Group_1_1__2__Impl ;
+ public final void rule__ExplicitArgList__Group_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12547:1: ( rule__ExplicitArgList__Group_1_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12548:2: rule__ExplicitArgList__Group_1_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ExplicitArgList__Group_1_1__2__Impl_in_rule__ExplicitArgList__Group_1_1__225547);
+ rule__ExplicitArgList__Group_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_1__2"
+
+
+ // $ANTLR start "rule__ExplicitArgList__Group_1_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12554:1: rule__ExplicitArgList__Group_1_1__2__Impl : ( RULE_OUTDENT ) ;
+ public final void rule__ExplicitArgList__Group_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12558:1: ( ( RULE_OUTDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12559:1: ( RULE_OUTDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12559:1: ( RULE_OUTDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12560:1: RULE_OUTDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+ match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rule__ExplicitArgList__Group_1_1__2__Impl25574); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__Group_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__ArgList__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12577:1: rule__ArgList__Group__0 : rule__ArgList__Group__0__Impl rule__ArgList__Group__1 ;
+ public final void rule__ArgList__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12581:1: ( rule__ArgList__Group__0__Impl rule__ArgList__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12582:2: rule__ArgList__Group__0__Impl rule__ArgList__Group__1
+ {
+ pushFollow(FOLLOW_rule__ArgList__Group__0__Impl_in_rule__ArgList__Group__025609);
+ rule__ArgList__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ArgList__Group__1_in_rule__ArgList__Group__025612);
+ rule__ArgList__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group__0"
+
+
+ // $ANTLR start "rule__ArgList__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12589:1: rule__ArgList__Group__0__Impl : ( () ) ;
+ public final void rule__ArgList__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12593:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12594:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12594:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12595:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getArgListAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12596:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12598:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getArgListAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ArgList__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12608:1: rule__ArgList__Group__1 : rule__ArgList__Group__1__Impl ;
+ public final void rule__ArgList__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12612:1: ( rule__ArgList__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12613:2: rule__ArgList__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ArgList__Group__1__Impl_in_rule__ArgList__Group__125670);
+ rule__ArgList__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group__1"
+
+
+ // $ANTLR start "rule__ArgList__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12619:1: rule__ArgList__Group__1__Impl : ( ( rule__ArgList__Alternatives_1 )? ) ;
+ public final void rule__ArgList__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12623:1: ( ( ( rule__ArgList__Alternatives_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12624:1: ( ( rule__ArgList__Alternatives_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12624:1: ( ( rule__ArgList__Alternatives_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12625:1: ( rule__ArgList__Alternatives_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getAlternatives_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12626:1: ( rule__ArgList__Alternatives_1 )?
+ int alt96=2;
+ int LA96_0 = input.LA(1);
+
+ if ( ((LA96_0>=RULE_PLUS && LA96_0<=RULE_MINUS_MINUS)||(LA96_0>=RULE_AT_SIGIL && LA96_0<=RULE_BOUND_FUNC_ARROW)||LA96_0==RULE_PARAM_START||(LA96_0>=RULE_FOR && LA96_0<=RULE_WHILE)||LA96_0==RULE_UNTIL||(LA96_0>=RULE_LBRACKET && LA96_0<=RULE_INDENT)||LA96_0==RULE_SUPER||(LA96_0>=RULE_THIS && LA96_0<=RULE_TRY)||LA96_0==RULE_SWITCH||LA96_0==RULE_LCURLY||(LA96_0>=RULE_NUMBER && LA96_0<=RULE_REGEX)||LA96_0==RULE_LPAREN||(LA96_0>=RULE_IF && LA96_0<=RULE_IDENTIFIER)) ) {
+ alt96=1;
+ }
+ switch (alt96) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12626:2: rule__ArgList__Alternatives_1
+ {
+ pushFollow(FOLLOW_rule__ArgList__Alternatives_1_in_rule__ArgList__Group__1__Impl25697);
+ rule__ArgList__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ArgList__Group_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12640:1: rule__ArgList__Group_1_1__0 : rule__ArgList__Group_1_1__0__Impl rule__ArgList__Group_1_1__1 ;
+ public final void rule__ArgList__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12644:1: ( rule__ArgList__Group_1_1__0__Impl rule__ArgList__Group_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12645:2: rule__ArgList__Group_1_1__0__Impl rule__ArgList__Group_1_1__1
+ {
+ pushFollow(FOLLOW_rule__ArgList__Group_1_1__0__Impl_in_rule__ArgList__Group_1_1__025732);
+ rule__ArgList__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ArgList__Group_1_1__1_in_rule__ArgList__Group_1_1__025735);
+ rule__ArgList__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group_1_1__0"
+
+
+ // $ANTLR start "rule__ArgList__Group_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12652:1: rule__ArgList__Group_1_1__0__Impl : ( RULE_INDENT ) ;
+ public final void rule__ArgList__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12656:1: ( ( RULE_INDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12657:1: ( RULE_INDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12657:1: ( RULE_INDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12658:1: RULE_INDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rule__ArgList__Group_1_1__0__Impl25762); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__ArgList__Group_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12669:1: rule__ArgList__Group_1_1__1 : rule__ArgList__Group_1_1__1__Impl rule__ArgList__Group_1_1__2 ;
+ public final void rule__ArgList__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12673:1: ( rule__ArgList__Group_1_1__1__Impl rule__ArgList__Group_1_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12674:2: rule__ArgList__Group_1_1__1__Impl rule__ArgList__Group_1_1__2
+ {
+ pushFollow(FOLLOW_rule__ArgList__Group_1_1__1__Impl_in_rule__ArgList__Group_1_1__125791);
+ rule__ArgList__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ArgList__Group_1_1__2_in_rule__ArgList__Group_1_1__125794);
+ rule__ArgList__Group_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group_1_1__1"
+
+
+ // $ANTLR start "rule__ArgList__Group_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12681:1: rule__ArgList__Group_1_1__1__Impl : ( ( rule__ArgList__DummyAssignment_1_1_1 ) ) ;
+ public final void rule__ArgList__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12685:1: ( ( ( rule__ArgList__DummyAssignment_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12686:1: ( ( rule__ArgList__DummyAssignment_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12686:1: ( ( rule__ArgList__DummyAssignment_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12687:1: ( rule__ArgList__DummyAssignment_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getDummyAssignment_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12688:1: ( rule__ArgList__DummyAssignment_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12688:2: rule__ArgList__DummyAssignment_1_1_1
+ {
+ pushFollow(FOLLOW_rule__ArgList__DummyAssignment_1_1_1_in_rule__ArgList__Group_1_1__1__Impl25821);
+ rule__ArgList__DummyAssignment_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getDummyAssignment_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__ArgList__Group_1_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12698:1: rule__ArgList__Group_1_1__2 : rule__ArgList__Group_1_1__2__Impl ;
+ public final void rule__ArgList__Group_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12702:1: ( rule__ArgList__Group_1_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12703:2: rule__ArgList__Group_1_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ArgList__Group_1_1__2__Impl_in_rule__ArgList__Group_1_1__225851);
+ rule__ArgList__Group_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group_1_1__2"
+
+
+ // $ANTLR start "rule__ArgList__Group_1_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12709:1: rule__ArgList__Group_1_1__2__Impl : ( RULE_OUTDENT ) ;
+ public final void rule__ArgList__Group_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12713:1: ( ( RULE_OUTDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12714:1: ( RULE_OUTDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12714:1: ( RULE_OUTDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12715:1: RULE_OUTDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+ match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rule__ArgList__Group_1_1__2__Impl25878); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__Group_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__Array__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12732:1: rule__Array__Group__0 : rule__Array__Group__0__Impl rule__Array__Group__1 ;
+ public final void rule__Array__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12736:1: ( rule__Array__Group__0__Impl rule__Array__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12737:2: rule__Array__Group__0__Impl rule__Array__Group__1
+ {
+ pushFollow(FOLLOW_rule__Array__Group__0__Impl_in_rule__Array__Group__025913);
+ rule__Array__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Array__Group__1_in_rule__Array__Group__025916);
+ rule__Array__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Array__Group__0"
+
+
+ // $ANTLR start "rule__Array__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12744:1: rule__Array__Group__0__Impl : ( ( RULE_LBRACKET ) ) ;
+ public final void rule__Array__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12748:1: ( ( ( RULE_LBRACKET ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12749:1: ( ( RULE_LBRACKET ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12749:1: ( ( RULE_LBRACKET ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12750:1: ( RULE_LBRACKET )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12751:1: ( RULE_LBRACKET )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12751:3: RULE_LBRACKET
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_rule__Array__Group__0__Impl25944); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Array__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Array__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12761:1: rule__Array__Group__1 : rule__Array__Group__1__Impl rule__Array__Group__2 ;
+ public final void rule__Array__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12765:1: ( rule__Array__Group__1__Impl rule__Array__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12766:2: rule__Array__Group__1__Impl rule__Array__Group__2
+ {
+ pushFollow(FOLLOW_rule__Array__Group__1__Impl_in_rule__Array__Group__125974);
+ rule__Array__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Array__Group__2_in_rule__Array__Group__125977);
+ rule__Array__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Array__Group__1"
+
+
+ // $ANTLR start "rule__Array__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12773:1: rule__Array__Group__1__Impl : ( ruleArgList ) ;
+ public final void rule__Array__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12777:1: ( ( ruleArgList ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12778:1: ( ruleArgList )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12778:1: ( ruleArgList )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12779:1: ruleArgList
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArrayAccess().getArgListParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleArgList_in_rule__Array__Group__1__Impl26004);
+ ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArrayAccess().getArgListParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Array__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Array__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12790:1: rule__Array__Group__2 : rule__Array__Group__2__Impl ;
+ public final void rule__Array__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12794:1: ( rule__Array__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12795:2: rule__Array__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Array__Group__2__Impl_in_rule__Array__Group__226033);
+ rule__Array__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Array__Group__2"
+
+
+ // $ANTLR start "rule__Array__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12801:1: rule__Array__Group__2__Impl : ( RULE_RBRACKET ) ;
+ public final void rule__Array__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12805:1: ( ( RULE_RBRACKET ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12806:1: ( RULE_RBRACKET )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12806:1: ( RULE_RBRACKET )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12807:1: RULE_RBRACKET
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2());
+ }
+ match(input,RULE_RBRACKET,FOLLOW_RULE_RBRACKET_in_rule__Array__Group__2__Impl26060); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Array__Group__2__Impl"
+
+
+ // $ANTLR start "rule__Dictionary__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12824:1: rule__Dictionary__Group__0 : rule__Dictionary__Group__0__Impl rule__Dictionary__Group__1 ;
+ public final void rule__Dictionary__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12828:1: ( rule__Dictionary__Group__0__Impl rule__Dictionary__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12829:2: rule__Dictionary__Group__0__Impl rule__Dictionary__Group__1
+ {
+ pushFollow(FOLLOW_rule__Dictionary__Group__0__Impl_in_rule__Dictionary__Group__026095);
+ rule__Dictionary__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Dictionary__Group__1_in_rule__Dictionary__Group__026098);
+ rule__Dictionary__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Dictionary__Group__0"
+
+
+ // $ANTLR start "rule__Dictionary__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12836:1: rule__Dictionary__Group__0__Impl : ( ( RULE_LCURLY ) ) ;
+ public final void rule__Dictionary__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12840:1: ( ( ( RULE_LCURLY ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12841:1: ( ( RULE_LCURLY ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12841:1: ( ( RULE_LCURLY ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12842:1: ( RULE_LCURLY )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12843:1: ( RULE_LCURLY )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12843:3: RULE_LCURLY
+ {
+ match(input,RULE_LCURLY,FOLLOW_RULE_LCURLY_in_rule__Dictionary__Group__0__Impl26126); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Dictionary__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Dictionary__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12853:1: rule__Dictionary__Group__1 : rule__Dictionary__Group__1__Impl rule__Dictionary__Group__2 ;
+ public final void rule__Dictionary__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12857:1: ( rule__Dictionary__Group__1__Impl rule__Dictionary__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12858:2: rule__Dictionary__Group__1__Impl rule__Dictionary__Group__2
+ {
+ pushFollow(FOLLOW_rule__Dictionary__Group__1__Impl_in_rule__Dictionary__Group__126156);
+ rule__Dictionary__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Dictionary__Group__2_in_rule__Dictionary__Group__126159);
+ rule__Dictionary__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Dictionary__Group__1"
+
+
+ // $ANTLR start "rule__Dictionary__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12865:1: rule__Dictionary__Group__1__Impl : ( ruleDictItems ) ;
+ public final void rule__Dictionary__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12869:1: ( ( ruleDictItems ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12870:1: ( ruleDictItems )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12870:1: ( ruleDictItems )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12871:1: ruleDictItems
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1());
+ }
+ pushFollow(FOLLOW_ruleDictItems_in_rule__Dictionary__Group__1__Impl26186);
+ ruleDictItems();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Dictionary__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Dictionary__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12882:1: rule__Dictionary__Group__2 : rule__Dictionary__Group__2__Impl ;
+ public final void rule__Dictionary__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12886:1: ( rule__Dictionary__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12887:2: rule__Dictionary__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Dictionary__Group__2__Impl_in_rule__Dictionary__Group__226215);
+ rule__Dictionary__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Dictionary__Group__2"
+
+
+ // $ANTLR start "rule__Dictionary__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12893:1: rule__Dictionary__Group__2__Impl : ( RULE_RCURLY ) ;
+ public final void rule__Dictionary__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12897:1: ( ( RULE_RCURLY ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12898:1: ( RULE_RCURLY )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12898:1: ( RULE_RCURLY )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12899:1: RULE_RCURLY
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2());
+ }
+ match(input,RULE_RCURLY,FOLLOW_RULE_RCURLY_in_rule__Dictionary__Group__2__Impl26242); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Dictionary__Group__2__Impl"
+
+
+ // $ANTLR start "rule__DictItems__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12916:1: rule__DictItems__Group__0 : rule__DictItems__Group__0__Impl rule__DictItems__Group__1 ;
+ public final void rule__DictItems__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12920:1: ( rule__DictItems__Group__0__Impl rule__DictItems__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12921:2: rule__DictItems__Group__0__Impl rule__DictItems__Group__1
+ {
+ pushFollow(FOLLOW_rule__DictItems__Group__0__Impl_in_rule__DictItems__Group__026277);
+ rule__DictItems__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictItems__Group__1_in_rule__DictItems__Group__026280);
+ rule__DictItems__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group__0"
+
+
+ // $ANTLR start "rule__DictItems__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12928:1: rule__DictItems__Group__0__Impl : ( () ) ;
+ public final void rule__DictItems__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12932:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12933:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12933:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12934:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getDictItemsAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12935:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12937:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getDictItemsAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group__0__Impl"
+
+
+ // $ANTLR start "rule__DictItems__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12947:1: rule__DictItems__Group__1 : rule__DictItems__Group__1__Impl ;
+ public final void rule__DictItems__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12951:1: ( rule__DictItems__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12952:2: rule__DictItems__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__DictItems__Group__1__Impl_in_rule__DictItems__Group__126338);
+ rule__DictItems__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group__1"
+
+
+ // $ANTLR start "rule__DictItems__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12958:1: rule__DictItems__Group__1__Impl : ( ( rule__DictItems__Alternatives_1 )? ) ;
+ public final void rule__DictItems__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12962:1: ( ( ( rule__DictItems__Alternatives_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12963:1: ( ( rule__DictItems__Alternatives_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12963:1: ( ( rule__DictItems__Alternatives_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12964:1: ( rule__DictItems__Alternatives_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getAlternatives_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12965:1: ( rule__DictItems__Alternatives_1 )?
+ int alt97=2;
+ int LA97_0 = input.LA(1);
+
+ if ( (LA97_0==RULE_INDENT||(LA97_0>=RULE_NUMBER && LA97_0<=RULE_REGEX)||LA97_0==RULE_IDENTIFIER) ) {
+ alt97=1;
+ }
+ switch (alt97) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12965:2: rule__DictItems__Alternatives_1
+ {
+ pushFollow(FOLLOW_rule__DictItems__Alternatives_1_in_rule__DictItems__Group__1__Impl26365);
+ rule__DictItems__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group__1__Impl"
+
+
+ // $ANTLR start "rule__DictItems__Group_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12979:1: rule__DictItems__Group_1_1__0 : rule__DictItems__Group_1_1__0__Impl rule__DictItems__Group_1_1__1 ;
+ public final void rule__DictItems__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12983:1: ( rule__DictItems__Group_1_1__0__Impl rule__DictItems__Group_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12984:2: rule__DictItems__Group_1_1__0__Impl rule__DictItems__Group_1_1__1
+ {
+ pushFollow(FOLLOW_rule__DictItems__Group_1_1__0__Impl_in_rule__DictItems__Group_1_1__026400);
+ rule__DictItems__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictItems__Group_1_1__1_in_rule__DictItems__Group_1_1__026403);
+ rule__DictItems__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group_1_1__0"
+
+
+ // $ANTLR start "rule__DictItems__Group_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12991:1: rule__DictItems__Group_1_1__0__Impl : ( RULE_INDENT ) ;
+ public final void rule__DictItems__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12995:1: ( ( RULE_INDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12996:1: ( RULE_INDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12996:1: ( RULE_INDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:12997:1: RULE_INDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rule__DictItems__Group_1_1__0__Impl26430); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__DictItems__Group_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13008:1: rule__DictItems__Group_1_1__1 : rule__DictItems__Group_1_1__1__Impl rule__DictItems__Group_1_1__2 ;
+ public final void rule__DictItems__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13012:1: ( rule__DictItems__Group_1_1__1__Impl rule__DictItems__Group_1_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13013:2: rule__DictItems__Group_1_1__1__Impl rule__DictItems__Group_1_1__2
+ {
+ pushFollow(FOLLOW_rule__DictItems__Group_1_1__1__Impl_in_rule__DictItems__Group_1_1__126459);
+ rule__DictItems__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictItems__Group_1_1__2_in_rule__DictItems__Group_1_1__126462);
+ rule__DictItems__Group_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group_1_1__1"
+
+
+ // $ANTLR start "rule__DictItems__Group_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13020:1: rule__DictItems__Group_1_1__1__Impl : ( ( rule__DictItems__DummyAssignment_1_1_1 ) ) ;
+ public final void rule__DictItems__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13024:1: ( ( ( rule__DictItems__DummyAssignment_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13025:1: ( ( rule__DictItems__DummyAssignment_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13025:1: ( ( rule__DictItems__DummyAssignment_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13026:1: ( rule__DictItems__DummyAssignment_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getDummyAssignment_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13027:1: ( rule__DictItems__DummyAssignment_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13027:2: rule__DictItems__DummyAssignment_1_1_1
+ {
+ pushFollow(FOLLOW_rule__DictItems__DummyAssignment_1_1_1_in_rule__DictItems__Group_1_1__1__Impl26489);
+ rule__DictItems__DummyAssignment_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getDummyAssignment_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__DictItems__Group_1_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13037:1: rule__DictItems__Group_1_1__2 : rule__DictItems__Group_1_1__2__Impl ;
+ public final void rule__DictItems__Group_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13041:1: ( rule__DictItems__Group_1_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13042:2: rule__DictItems__Group_1_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__DictItems__Group_1_1__2__Impl_in_rule__DictItems__Group_1_1__226519);
+ rule__DictItems__Group_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group_1_1__2"
+
+
+ // $ANTLR start "rule__DictItems__Group_1_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13048:1: rule__DictItems__Group_1_1__2__Impl : ( RULE_OUTDENT ) ;
+ public final void rule__DictItems__Group_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13052:1: ( ( RULE_OUTDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13053:1: ( RULE_OUTDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13053:1: ( RULE_OUTDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13054:1: RULE_OUTDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+ match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rule__DictItems__Group_1_1__2__Impl26546); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__Group_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13071:1: rule__ExplicitDictItems__Group__0 : rule__ExplicitDictItems__Group__0__Impl rule__ExplicitDictItems__Group__1 ;
+ public final void rule__ExplicitDictItems__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13075:1: ( rule__ExplicitDictItems__Group__0__Impl rule__ExplicitDictItems__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13076:2: rule__ExplicitDictItems__Group__0__Impl rule__ExplicitDictItems__Group__1
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group__0__Impl_in_rule__ExplicitDictItems__Group__026581);
+ rule__ExplicitDictItems__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group__1_in_rule__ExplicitDictItems__Group__026584);
+ rule__ExplicitDictItems__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group__0"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13083:1: rule__ExplicitDictItems__Group__0__Impl : ( ( rule__ExplicitDictItems__LinesAssignment_0 ) ) ;
+ public final void rule__ExplicitDictItems__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13087:1: ( ( ( rule__ExplicitDictItems__LinesAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13088:1: ( ( rule__ExplicitDictItems__LinesAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13088:1: ( ( rule__ExplicitDictItems__LinesAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13089:1: ( rule__ExplicitDictItems__LinesAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13090:1: ( rule__ExplicitDictItems__LinesAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13090:2: rule__ExplicitDictItems__LinesAssignment_0
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__LinesAssignment_0_in_rule__ExplicitDictItems__Group__0__Impl26611);
+ rule__ExplicitDictItems__LinesAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group__0__Impl"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13100:1: rule__ExplicitDictItems__Group__1 : rule__ExplicitDictItems__Group__1__Impl ;
+ public final void rule__ExplicitDictItems__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13104:1: ( rule__ExplicitDictItems__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13105:2: rule__ExplicitDictItems__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group__1__Impl_in_rule__ExplicitDictItems__Group__126641);
+ rule__ExplicitDictItems__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group__1"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13111:1: rule__ExplicitDictItems__Group__1__Impl : ( ( rule__ExplicitDictItems__Alternatives_1 )* ) ;
+ public final void rule__ExplicitDictItems__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13115:1: ( ( ( rule__ExplicitDictItems__Alternatives_1 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13116:1: ( ( rule__ExplicitDictItems__Alternatives_1 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13116:1: ( ( rule__ExplicitDictItems__Alternatives_1 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13117:1: ( rule__ExplicitDictItems__Alternatives_1 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getAlternatives_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13118:1: ( rule__ExplicitDictItems__Alternatives_1 )*
+ loop98:
+ do {
+ int alt98=2;
+ int LA98_0 = input.LA(1);
+
+ if ( (LA98_0==RULE_TERMINATOR||LA98_0==RULE_INDENT) ) {
+ alt98=1;
+ }
+
+
+ switch (alt98) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13118:2: rule__ExplicitDictItems__Alternatives_1
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Alternatives_1_in_rule__ExplicitDictItems__Group__1__Impl26668);
+ rule__ExplicitDictItems__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop98;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group__1__Impl"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13132:1: rule__ExplicitDictItems__Group_1_0__0 : rule__ExplicitDictItems__Group_1_0__0__Impl rule__ExplicitDictItems__Group_1_0__1 ;
+ public final void rule__ExplicitDictItems__Group_1_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13136:1: ( rule__ExplicitDictItems__Group_1_0__0__Impl rule__ExplicitDictItems__Group_1_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13137:2: rule__ExplicitDictItems__Group_1_0__0__Impl rule__ExplicitDictItems__Group_1_0__1
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_0__0__Impl_in_rule__ExplicitDictItems__Group_1_0__026703);
+ rule__ExplicitDictItems__Group_1_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_0__1_in_rule__ExplicitDictItems__Group_1_0__026706);
+ rule__ExplicitDictItems__Group_1_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_0__0"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13144:1: rule__ExplicitDictItems__Group_1_0__0__Impl : ( RULE_TERMINATOR ) ;
+ public final void rule__ExplicitDictItems__Group_1_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13148:1: ( ( RULE_TERMINATOR ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13149:1: ( RULE_TERMINATOR )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13149:1: ( RULE_TERMINATOR )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13150:1: RULE_TERMINATOR
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0());
+ }
+ match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_rule__ExplicitDictItems__Group_1_0__0__Impl26733); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_0__0__Impl"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13161:1: rule__ExplicitDictItems__Group_1_0__1 : rule__ExplicitDictItems__Group_1_0__1__Impl ;
+ public final void rule__ExplicitDictItems__Group_1_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13165:1: ( rule__ExplicitDictItems__Group_1_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13166:2: rule__ExplicitDictItems__Group_1_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_0__1__Impl_in_rule__ExplicitDictItems__Group_1_0__126762);
+ rule__ExplicitDictItems__Group_1_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_0__1"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13172:1: rule__ExplicitDictItems__Group_1_0__1__Impl : ( ( rule__ExplicitDictItems__LinesAssignment_1_0_1 ) ) ;
+ public final void rule__ExplicitDictItems__Group_1_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13176:1: ( ( ( rule__ExplicitDictItems__LinesAssignment_1_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13177:1: ( ( rule__ExplicitDictItems__LinesAssignment_1_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13177:1: ( ( rule__ExplicitDictItems__LinesAssignment_1_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13178:1: ( rule__ExplicitDictItems__LinesAssignment_1_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13179:1: ( rule__ExplicitDictItems__LinesAssignment_1_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13179:2: rule__ExplicitDictItems__LinesAssignment_1_0_1
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__LinesAssignment_1_0_1_in_rule__ExplicitDictItems__Group_1_0__1__Impl26789);
+ rule__ExplicitDictItems__LinesAssignment_1_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_0__1__Impl"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13193:1: rule__ExplicitDictItems__Group_1_1__0 : rule__ExplicitDictItems__Group_1_1__0__Impl rule__ExplicitDictItems__Group_1_1__1 ;
+ public final void rule__ExplicitDictItems__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13197:1: ( rule__ExplicitDictItems__Group_1_1__0__Impl rule__ExplicitDictItems__Group_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13198:2: rule__ExplicitDictItems__Group_1_1__0__Impl rule__ExplicitDictItems__Group_1_1__1
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_1__0__Impl_in_rule__ExplicitDictItems__Group_1_1__026823);
+ rule__ExplicitDictItems__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_1__1_in_rule__ExplicitDictItems__Group_1_1__026826);
+ rule__ExplicitDictItems__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_1__0"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13205:1: rule__ExplicitDictItems__Group_1_1__0__Impl : ( RULE_INDENT ) ;
+ public final void rule__ExplicitDictItems__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13209:1: ( ( RULE_INDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13210:1: ( RULE_INDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13210:1: ( RULE_INDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13211:1: RULE_INDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rule__ExplicitDictItems__Group_1_1__0__Impl26853); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13222:1: rule__ExplicitDictItems__Group_1_1__1 : rule__ExplicitDictItems__Group_1_1__1__Impl rule__ExplicitDictItems__Group_1_1__2 ;
+ public final void rule__ExplicitDictItems__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13226:1: ( rule__ExplicitDictItems__Group_1_1__1__Impl rule__ExplicitDictItems__Group_1_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13227:2: rule__ExplicitDictItems__Group_1_1__1__Impl rule__ExplicitDictItems__Group_1_1__2
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_1__1__Impl_in_rule__ExplicitDictItems__Group_1_1__126882);
+ rule__ExplicitDictItems__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_1__2_in_rule__ExplicitDictItems__Group_1_1__126885);
+ rule__ExplicitDictItems__Group_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_1__1"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13234:1: rule__ExplicitDictItems__Group_1_1__1__Impl : ( ( rule__ExplicitDictItems__LinesAssignment_1_1_1 ) ) ;
+ public final void rule__ExplicitDictItems__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13238:1: ( ( ( rule__ExplicitDictItems__LinesAssignment_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13239:1: ( ( rule__ExplicitDictItems__LinesAssignment_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13239:1: ( ( rule__ExplicitDictItems__LinesAssignment_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13240:1: ( rule__ExplicitDictItems__LinesAssignment_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13241:1: ( rule__ExplicitDictItems__LinesAssignment_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13241:2: rule__ExplicitDictItems__LinesAssignment_1_1_1
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__LinesAssignment_1_1_1_in_rule__ExplicitDictItems__Group_1_1__1__Impl26912);
+ rule__ExplicitDictItems__LinesAssignment_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13251:1: rule__ExplicitDictItems__Group_1_1__2 : rule__ExplicitDictItems__Group_1_1__2__Impl ;
+ public final void rule__ExplicitDictItems__Group_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13255:1: ( rule__ExplicitDictItems__Group_1_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13256:2: rule__ExplicitDictItems__Group_1_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__ExplicitDictItems__Group_1_1__2__Impl_in_rule__ExplicitDictItems__Group_1_1__226942);
+ rule__ExplicitDictItems__Group_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_1__2"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__Group_1_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13262:1: rule__ExplicitDictItems__Group_1_1__2__Impl : ( RULE_OUTDENT ) ;
+ public final void rule__ExplicitDictItems__Group_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13266:1: ( ( RULE_OUTDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13267:1: ( RULE_OUTDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13267:1: ( RULE_OUTDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13268:1: RULE_OUTDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+ match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rule__ExplicitDictItems__Group_1_1__2__Impl26969); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__Group_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__DictLine__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13285:1: rule__DictLine__Group__0 : rule__DictLine__Group__0__Impl rule__DictLine__Group__1 ;
+ public final void rule__DictLine__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13289:1: ( rule__DictLine__Group__0__Impl rule__DictLine__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13290:2: rule__DictLine__Group__0__Impl rule__DictLine__Group__1
+ {
+ pushFollow(FOLLOW_rule__DictLine__Group__0__Impl_in_rule__DictLine__Group__027004);
+ rule__DictLine__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictLine__Group__1_in_rule__DictLine__Group__027007);
+ rule__DictLine__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group__0"
+
+
+ // $ANTLR start "rule__DictLine__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13297:1: rule__DictLine__Group__0__Impl : ( ( rule__DictLine__HeadAssignment_0 ) ) ;
+ public final void rule__DictLine__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13301:1: ( ( ( rule__DictLine__HeadAssignment_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13302:1: ( ( rule__DictLine__HeadAssignment_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13302:1: ( ( rule__DictLine__HeadAssignment_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13303:1: ( rule__DictLine__HeadAssignment_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictLineAccess().getHeadAssignment_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13304:1: ( rule__DictLine__HeadAssignment_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13304:2: rule__DictLine__HeadAssignment_0
+ {
+ pushFollow(FOLLOW_rule__DictLine__HeadAssignment_0_in_rule__DictLine__Group__0__Impl27034);
+ rule__DictLine__HeadAssignment_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictLineAccess().getHeadAssignment_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group__0__Impl"
+
+
+ // $ANTLR start "rule__DictLine__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13314:1: rule__DictLine__Group__1 : rule__DictLine__Group__1__Impl rule__DictLine__Group__2 ;
+ public final void rule__DictLine__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13318:1: ( rule__DictLine__Group__1__Impl rule__DictLine__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13319:2: rule__DictLine__Group__1__Impl rule__DictLine__Group__2
+ {
+ pushFollow(FOLLOW_rule__DictLine__Group__1__Impl_in_rule__DictLine__Group__127064);
+ rule__DictLine__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictLine__Group__2_in_rule__DictLine__Group__127067);
+ rule__DictLine__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group__1"
+
+
+ // $ANTLR start "rule__DictLine__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13326:1: rule__DictLine__Group__1__Impl : ( ( rule__DictLine__Group_1__0 )* ) ;
+ public final void rule__DictLine__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13330:1: ( ( ( rule__DictLine__Group_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13331:1: ( ( rule__DictLine__Group_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13331:1: ( ( rule__DictLine__Group_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13332:1: ( rule__DictLine__Group_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictLineAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13333:1: ( rule__DictLine__Group_1__0 )*
+ loop99:
+ do {
+ int alt99=2;
+ int LA99_0 = input.LA(1);
+
+ if ( (LA99_0==RULE_COMMA) ) {
+ int LA99_1 = input.LA(2);
+
+ if ( ((LA99_1>=RULE_NUMBER && LA99_1<=RULE_REGEX)||LA99_1==RULE_IDENTIFIER) ) {
+ alt99=1;
+ }
+
+
+ }
+
+
+ switch (alt99) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13333:2: rule__DictLine__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__DictLine__Group_1__0_in_rule__DictLine__Group__1__Impl27094);
+ rule__DictLine__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop99;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictLineAccess().getGroup_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group__1__Impl"
+
+
+ // $ANTLR start "rule__DictLine__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13343:1: rule__DictLine__Group__2 : rule__DictLine__Group__2__Impl ;
+ public final void rule__DictLine__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13347:1: ( rule__DictLine__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13348:2: rule__DictLine__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__DictLine__Group__2__Impl_in_rule__DictLine__Group__227125);
+ rule__DictLine__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group__2"
+
+
+ // $ANTLR start "rule__DictLine__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13354:1: rule__DictLine__Group__2__Impl : ( ( RULE_COMMA )? ) ;
+ public final void rule__DictLine__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13358:1: ( ( ( RULE_COMMA )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13359:1: ( ( RULE_COMMA )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13359:1: ( ( RULE_COMMA )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13360:1: ( RULE_COMMA )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13361:1: ( RULE_COMMA )?
+ int alt100=2;
+ int LA100_0 = input.LA(1);
+
+ if ( (LA100_0==RULE_COMMA) ) {
+ alt100=1;
+ }
+ switch (alt100) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13361:3: RULE_COMMA
+ {
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__DictLine__Group__2__Impl27153); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group__2__Impl"
+
+
+ // $ANTLR start "rule__DictLine__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13377:1: rule__DictLine__Group_1__0 : rule__DictLine__Group_1__0__Impl rule__DictLine__Group_1__1 ;
+ public final void rule__DictLine__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13381:1: ( rule__DictLine__Group_1__0__Impl rule__DictLine__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13382:2: rule__DictLine__Group_1__0__Impl rule__DictLine__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__DictLine__Group_1__0__Impl_in_rule__DictLine__Group_1__027190);
+ rule__DictLine__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictLine__Group_1__1_in_rule__DictLine__Group_1__027193);
+ rule__DictLine__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group_1__0"
+
+
+ // $ANTLR start "rule__DictLine__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13389:1: rule__DictLine__Group_1__0__Impl : ( RULE_COMMA ) ;
+ public final void rule__DictLine__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13393:1: ( ( RULE_COMMA ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13394:1: ( RULE_COMMA )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13394:1: ( RULE_COMMA )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13395:1: RULE_COMMA
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0());
+ }
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__DictLine__Group_1__0__Impl27220); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__DictLine__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13406:1: rule__DictLine__Group_1__1 : rule__DictLine__Group_1__1__Impl ;
+ public final void rule__DictLine__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13410:1: ( rule__DictLine__Group_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13411:2: rule__DictLine__Group_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__DictLine__Group_1__1__Impl_in_rule__DictLine__Group_1__127249);
+ rule__DictLine__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group_1__1"
+
+
+ // $ANTLR start "rule__DictLine__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13417:1: rule__DictLine__Group_1__1__Impl : ( ( rule__DictLine__TailAssignment_1_1 ) ) ;
+ public final void rule__DictLine__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13421:1: ( ( ( rule__DictLine__TailAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13422:1: ( ( rule__DictLine__TailAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13422:1: ( ( rule__DictLine__TailAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13423:1: ( rule__DictLine__TailAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictLineAccess().getTailAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13424:1: ( rule__DictLine__TailAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13424:2: rule__DictLine__TailAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__DictLine__TailAssignment_1_1_in_rule__DictLine__Group_1__1__Impl27276);
+ rule__DictLine__TailAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictLineAccess().getTailAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__DictItem__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13438:1: rule__DictItem__Group__0 : rule__DictItem__Group__0__Impl rule__DictItem__Group__1 ;
+ public final void rule__DictItem__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13442:1: ( rule__DictItem__Group__0__Impl rule__DictItem__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13443:2: rule__DictItem__Group__0__Impl rule__DictItem__Group__1
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group__0__Impl_in_rule__DictItem__Group__027310);
+ rule__DictItem__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictItem__Group__1_in_rule__DictItem__Group__027313);
+ rule__DictItem__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group__0"
+
+
+ // $ANTLR start "rule__DictItem__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13450:1: rule__DictItem__Group__0__Impl : ( () ) ;
+ public final void rule__DictItem__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13454:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13455:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13455:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13456:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getDictItemAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13457:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13459:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getDictItemAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group__0__Impl"
+
+
+ // $ANTLR start "rule__DictItem__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13469:1: rule__DictItem__Group__1 : rule__DictItem__Group__1__Impl rule__DictItem__Group__2 ;
+ public final void rule__DictItem__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13473:1: ( rule__DictItem__Group__1__Impl rule__DictItem__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13474:2: rule__DictItem__Group__1__Impl rule__DictItem__Group__2
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group__1__Impl_in_rule__DictItem__Group__127371);
+ rule__DictItem__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictItem__Group__2_in_rule__DictItem__Group__127374);
+ rule__DictItem__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group__1"
+
+
+ // $ANTLR start "rule__DictItem__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13481:1: rule__DictItem__Group__1__Impl : ( ( rule__DictItem__KeyAssignment_1 ) ) ;
+ public final void rule__DictItem__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13485:1: ( ( ( rule__DictItem__KeyAssignment_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13486:1: ( ( rule__DictItem__KeyAssignment_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13486:1: ( ( rule__DictItem__KeyAssignment_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13487:1: ( rule__DictItem__KeyAssignment_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getKeyAssignment_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13488:1: ( rule__DictItem__KeyAssignment_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13488:2: rule__DictItem__KeyAssignment_1
+ {
+ pushFollow(FOLLOW_rule__DictItem__KeyAssignment_1_in_rule__DictItem__Group__1__Impl27401);
+ rule__DictItem__KeyAssignment_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getKeyAssignment_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group__1__Impl"
+
+
+ // $ANTLR start "rule__DictItem__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13498:1: rule__DictItem__Group__2 : rule__DictItem__Group__2__Impl ;
+ public final void rule__DictItem__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13502:1: ( rule__DictItem__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13503:2: rule__DictItem__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group__2__Impl_in_rule__DictItem__Group__227431);
+ rule__DictItem__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group__2"
+
+
+ // $ANTLR start "rule__DictItem__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13509:1: rule__DictItem__Group__2__Impl : ( ( rule__DictItem__Group_2__0 )? ) ;
+ public final void rule__DictItem__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13513:1: ( ( ( rule__DictItem__Group_2__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13514:1: ( ( rule__DictItem__Group_2__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13514:1: ( ( rule__DictItem__Group_2__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13515:1: ( rule__DictItem__Group_2__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getGroup_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13516:1: ( rule__DictItem__Group_2__0 )?
+ int alt101=2;
+ int LA101_0 = input.LA(1);
+
+ if ( (LA101_0==RULE_COLON) ) {
+ alt101=1;
+ }
+ switch (alt101) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13516:2: rule__DictItem__Group_2__0
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group_2__0_in_rule__DictItem__Group__2__Impl27458);
+ rule__DictItem__Group_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getGroup_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group__2__Impl"
+
+
+ // $ANTLR start "rule__DictItem__Group_2__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13532:1: rule__DictItem__Group_2__0 : rule__DictItem__Group_2__0__Impl rule__DictItem__Group_2__1 ;
+ public final void rule__DictItem__Group_2__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13536:1: ( rule__DictItem__Group_2__0__Impl rule__DictItem__Group_2__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13537:2: rule__DictItem__Group_2__0__Impl rule__DictItem__Group_2__1
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group_2__0__Impl_in_rule__DictItem__Group_2__027495);
+ rule__DictItem__Group_2__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictItem__Group_2__1_in_rule__DictItem__Group_2__027498);
+ rule__DictItem__Group_2__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2__0"
+
+
+ // $ANTLR start "rule__DictItem__Group_2__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13544:1: rule__DictItem__Group_2__0__Impl : ( RULE_COLON ) ;
+ public final void rule__DictItem__Group_2__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13548:1: ( ( RULE_COLON ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13549:1: ( RULE_COLON )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13549:1: ( RULE_COLON )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13550:1: RULE_COLON
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0());
+ }
+ match(input,RULE_COLON,FOLLOW_RULE_COLON_in_rule__DictItem__Group_2__0__Impl27525); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2__0__Impl"
+
+
+ // $ANTLR start "rule__DictItem__Group_2__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13561:1: rule__DictItem__Group_2__1 : rule__DictItem__Group_2__1__Impl ;
+ public final void rule__DictItem__Group_2__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13565:1: ( rule__DictItem__Group_2__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13566:2: rule__DictItem__Group_2__1__Impl
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group_2__1__Impl_in_rule__DictItem__Group_2__127554);
+ rule__DictItem__Group_2__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2__1"
+
+
+ // $ANTLR start "rule__DictItem__Group_2__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13572:1: rule__DictItem__Group_2__1__Impl : ( ( rule__DictItem__Alternatives_2_1 ) ) ;
+ public final void rule__DictItem__Group_2__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13576:1: ( ( ( rule__DictItem__Alternatives_2_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13577:1: ( ( rule__DictItem__Alternatives_2_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13577:1: ( ( rule__DictItem__Alternatives_2_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13578:1: ( rule__DictItem__Alternatives_2_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getAlternatives_2_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13579:1: ( rule__DictItem__Alternatives_2_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13579:2: rule__DictItem__Alternatives_2_1
+ {
+ pushFollow(FOLLOW_rule__DictItem__Alternatives_2_1_in_rule__DictItem__Group_2__1__Impl27581);
+ rule__DictItem__Alternatives_2_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getAlternatives_2_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2__1__Impl"
+
+
+ // $ANTLR start "rule__DictItem__Group_2_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13593:1: rule__DictItem__Group_2_1_1__0 : rule__DictItem__Group_2_1_1__0__Impl rule__DictItem__Group_2_1_1__1 ;
+ public final void rule__DictItem__Group_2_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13597:1: ( rule__DictItem__Group_2_1_1__0__Impl rule__DictItem__Group_2_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13598:2: rule__DictItem__Group_2_1_1__0__Impl rule__DictItem__Group_2_1_1__1
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group_2_1_1__0__Impl_in_rule__DictItem__Group_2_1_1__027615);
+ rule__DictItem__Group_2_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictItem__Group_2_1_1__1_in_rule__DictItem__Group_2_1_1__027618);
+ rule__DictItem__Group_2_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2_1_1__0"
+
+
+ // $ANTLR start "rule__DictItem__Group_2_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13605:1: rule__DictItem__Group_2_1_1__0__Impl : ( RULE_INDENT ) ;
+ public final void rule__DictItem__Group_2_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13609:1: ( ( RULE_INDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13610:1: ( RULE_INDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13610:1: ( RULE_INDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13611:1: RULE_INDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0());
+ }
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rule__DictItem__Group_2_1_1__0__Impl27645); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__DictItem__Group_2_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13622:1: rule__DictItem__Group_2_1_1__1 : rule__DictItem__Group_2_1_1__1__Impl rule__DictItem__Group_2_1_1__2 ;
+ public final void rule__DictItem__Group_2_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13626:1: ( rule__DictItem__Group_2_1_1__1__Impl rule__DictItem__Group_2_1_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13627:2: rule__DictItem__Group_2_1_1__1__Impl rule__DictItem__Group_2_1_1__2
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group_2_1_1__1__Impl_in_rule__DictItem__Group_2_1_1__127674);
+ rule__DictItem__Group_2_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__DictItem__Group_2_1_1__2_in_rule__DictItem__Group_2_1_1__127677);
+ rule__DictItem__Group_2_1_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2_1_1__1"
+
+
+ // $ANTLR start "rule__DictItem__Group_2_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13634:1: rule__DictItem__Group_2_1_1__1__Impl : ( ( rule__DictItem__ValueAssignment_2_1_1_1 ) ) ;
+ public final void rule__DictItem__Group_2_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13638:1: ( ( ( rule__DictItem__ValueAssignment_2_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13639:1: ( ( rule__DictItem__ValueAssignment_2_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13639:1: ( ( rule__DictItem__ValueAssignment_2_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13640:1: ( rule__DictItem__ValueAssignment_2_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getValueAssignment_2_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13641:1: ( rule__DictItem__ValueAssignment_2_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13641:2: rule__DictItem__ValueAssignment_2_1_1_1
+ {
+ pushFollow(FOLLOW_rule__DictItem__ValueAssignment_2_1_1_1_in_rule__DictItem__Group_2_1_1__1__Impl27704);
+ rule__DictItem__ValueAssignment_2_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getValueAssignment_2_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__DictItem__Group_2_1_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13651:1: rule__DictItem__Group_2_1_1__2 : rule__DictItem__Group_2_1_1__2__Impl ;
+ public final void rule__DictItem__Group_2_1_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13655:1: ( rule__DictItem__Group_2_1_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13656:2: rule__DictItem__Group_2_1_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__DictItem__Group_2_1_1__2__Impl_in_rule__DictItem__Group_2_1_1__227734);
+ rule__DictItem__Group_2_1_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2_1_1__2"
+
+
+ // $ANTLR start "rule__DictItem__Group_2_1_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13662:1: rule__DictItem__Group_2_1_1__2__Impl : ( RULE_OUTDENT ) ;
+ public final void rule__DictItem__Group_2_1_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13666:1: ( ( RULE_OUTDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13667:1: ( RULE_OUTDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13667:1: ( RULE_OUTDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13668:1: RULE_OUTDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2());
+ }
+ match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rule__DictItem__Group_2_1_1__2__Impl27761); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__Group_2_1_1__2__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13685:1: rule__Lambda__Group__0 : rule__Lambda__Group__0__Impl rule__Lambda__Group__1 ;
+ public final void rule__Lambda__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13689:1: ( rule__Lambda__Group__0__Impl rule__Lambda__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13690:2: rule__Lambda__Group__0__Impl rule__Lambda__Group__1
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group__0__Impl_in_rule__Lambda__Group__027796);
+ rule__Lambda__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Lambda__Group__1_in_rule__Lambda__Group__027799);
+ rule__Lambda__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group__0"
+
+
+ // $ANTLR start "rule__Lambda__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13697:1: rule__Lambda__Group__0__Impl : ( ( rule__Lambda__Group_0__0 )? ) ;
+ public final void rule__Lambda__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13701:1: ( ( ( rule__Lambda__Group_0__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13702:1: ( ( rule__Lambda__Group_0__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13702:1: ( ( rule__Lambda__Group_0__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13703:1: ( rule__Lambda__Group_0__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13704:1: ( rule__Lambda__Group_0__0 )?
+ int alt102=2;
+ int LA102_0 = input.LA(1);
+
+ if ( (LA102_0==RULE_PARAM_START) ) {
+ alt102=1;
+ }
+ switch (alt102) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13704:2: rule__Lambda__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0__0_in_rule__Lambda__Group__0__Impl27826);
+ rule__Lambda__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getGroup_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13714:1: rule__Lambda__Group__1 : rule__Lambda__Group__1__Impl rule__Lambda__Group__2 ;
+ public final void rule__Lambda__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13718:1: ( rule__Lambda__Group__1__Impl rule__Lambda__Group__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13719:2: rule__Lambda__Group__1__Impl rule__Lambda__Group__2
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group__1__Impl_in_rule__Lambda__Group__127857);
+ rule__Lambda__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Lambda__Group__2_in_rule__Lambda__Group__127860);
+ rule__Lambda__Group__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group__1"
+
+
+ // $ANTLR start "rule__Lambda__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13726:1: rule__Lambda__Group__1__Impl : ( ( rule__Lambda__Alternatives_1 ) ) ;
+ public final void rule__Lambda__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13730:1: ( ( ( rule__Lambda__Alternatives_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13731:1: ( ( rule__Lambda__Alternatives_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13731:1: ( ( rule__Lambda__Alternatives_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13732:1: ( rule__Lambda__Alternatives_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getAlternatives_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13733:1: ( rule__Lambda__Alternatives_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13733:2: rule__Lambda__Alternatives_1
+ {
+ pushFollow(FOLLOW_rule__Lambda__Alternatives_1_in_rule__Lambda__Group__1__Impl27887);
+ rule__Lambda__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13743:1: rule__Lambda__Group__2 : rule__Lambda__Group__2__Impl ;
+ public final void rule__Lambda__Group__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13747:1: ( rule__Lambda__Group__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13748:2: rule__Lambda__Group__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group__2__Impl_in_rule__Lambda__Group__227917);
+ rule__Lambda__Group__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group__2"
+
+
+ // $ANTLR start "rule__Lambda__Group__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13754:1: rule__Lambda__Group__2__Impl : ( ( rule__Lambda__BodyAssignment_2 ) ) ;
+ public final void rule__Lambda__Group__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13758:1: ( ( ( rule__Lambda__BodyAssignment_2 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13759:1: ( ( rule__Lambda__BodyAssignment_2 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13759:1: ( ( rule__Lambda__BodyAssignment_2 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13760:1: ( rule__Lambda__BodyAssignment_2 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getBodyAssignment_2());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13761:1: ( rule__Lambda__BodyAssignment_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13761:2: rule__Lambda__BodyAssignment_2
+ {
+ pushFollow(FOLLOW_rule__Lambda__BodyAssignment_2_in_rule__Lambda__Group__2__Impl27944);
+ rule__Lambda__BodyAssignment_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getBodyAssignment_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group__2__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13777:1: rule__Lambda__Group_0__0 : rule__Lambda__Group_0__0__Impl rule__Lambda__Group_0__1 ;
+ public final void rule__Lambda__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13781:1: ( rule__Lambda__Group_0__0__Impl rule__Lambda__Group_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13782:2: rule__Lambda__Group_0__0__Impl rule__Lambda__Group_0__1
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0__0__Impl_in_rule__Lambda__Group_0__027980);
+ rule__Lambda__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Lambda__Group_0__1_in_rule__Lambda__Group_0__027983);
+ rule__Lambda__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0__0"
+
+
+ // $ANTLR start "rule__Lambda__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13789:1: rule__Lambda__Group_0__0__Impl : ( RULE_PARAM_START ) ;
+ public final void rule__Lambda__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13793:1: ( ( RULE_PARAM_START ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13794:1: ( RULE_PARAM_START )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13794:1: ( RULE_PARAM_START )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13795:1: RULE_PARAM_START
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0());
+ }
+ match(input,RULE_PARAM_START,FOLLOW_RULE_PARAM_START_in_rule__Lambda__Group_0__0__Impl28010); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13806:1: rule__Lambda__Group_0__1 : rule__Lambda__Group_0__1__Impl rule__Lambda__Group_0__2 ;
+ public final void rule__Lambda__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13810:1: ( rule__Lambda__Group_0__1__Impl rule__Lambda__Group_0__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13811:2: rule__Lambda__Group_0__1__Impl rule__Lambda__Group_0__2
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0__1__Impl_in_rule__Lambda__Group_0__128039);
+ rule__Lambda__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Lambda__Group_0__2_in_rule__Lambda__Group_0__128042);
+ rule__Lambda__Group_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0__1"
+
+
+ // $ANTLR start "rule__Lambda__Group_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13818:1: rule__Lambda__Group_0__1__Impl : ( ( rule__Lambda__Group_0_1__0 )? ) ;
+ public final void rule__Lambda__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13822:1: ( ( ( rule__Lambda__Group_0_1__0 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13823:1: ( ( rule__Lambda__Group_0_1__0 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13823:1: ( ( rule__Lambda__Group_0_1__0 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13824:1: ( rule__Lambda__Group_0_1__0 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getGroup_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13825:1: ( rule__Lambda__Group_0_1__0 )?
+ int alt103=2;
+ int LA103_0 = input.LA(1);
+
+ if ( (LA103_0==RULE_AT_SIGIL||LA103_0==RULE_LBRACKET||LA103_0==RULE_LCURLY||LA103_0==RULE_IDENTIFIER) ) {
+ alt103=1;
+ }
+ switch (alt103) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13825:2: rule__Lambda__Group_0_1__0
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0_1__0_in_rule__Lambda__Group_0__1__Impl28069);
+ rule__Lambda__Group_0_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getGroup_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group_0__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13835:1: rule__Lambda__Group_0__2 : rule__Lambda__Group_0__2__Impl ;
+ public final void rule__Lambda__Group_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13839:1: ( rule__Lambda__Group_0__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13840:2: rule__Lambda__Group_0__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0__2__Impl_in_rule__Lambda__Group_0__228100);
+ rule__Lambda__Group_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0__2"
+
+
+ // $ANTLR start "rule__Lambda__Group_0__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13846:1: rule__Lambda__Group_0__2__Impl : ( RULE_PARAM_END ) ;
+ public final void rule__Lambda__Group_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13850:1: ( ( RULE_PARAM_END ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13851:1: ( RULE_PARAM_END )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13851:1: ( RULE_PARAM_END )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13852:1: RULE_PARAM_END
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2());
+ }
+ match(input,RULE_PARAM_END,FOLLOW_RULE_PARAM_END_in_rule__Lambda__Group_0__2__Impl28127); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0__2__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group_0_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13869:1: rule__Lambda__Group_0_1__0 : rule__Lambda__Group_0_1__0__Impl rule__Lambda__Group_0_1__1 ;
+ public final void rule__Lambda__Group_0_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13873:1: ( rule__Lambda__Group_0_1__0__Impl rule__Lambda__Group_0_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13874:2: rule__Lambda__Group_0_1__0__Impl rule__Lambda__Group_0_1__1
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0_1__0__Impl_in_rule__Lambda__Group_0_1__028162);
+ rule__Lambda__Group_0_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Lambda__Group_0_1__1_in_rule__Lambda__Group_0_1__028165);
+ rule__Lambda__Group_0_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0_1__0"
+
+
+ // $ANTLR start "rule__Lambda__Group_0_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13881:1: rule__Lambda__Group_0_1__0__Impl : ( ( rule__Lambda__ParamsAssignment_0_1_0 ) ) ;
+ public final void rule__Lambda__Group_0_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13885:1: ( ( ( rule__Lambda__ParamsAssignment_0_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13886:1: ( ( rule__Lambda__ParamsAssignment_0_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13886:1: ( ( rule__Lambda__ParamsAssignment_0_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13887:1: ( rule__Lambda__ParamsAssignment_0_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13888:1: ( rule__Lambda__ParamsAssignment_0_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13888:2: rule__Lambda__ParamsAssignment_0_1_0
+ {
+ pushFollow(FOLLOW_rule__Lambda__ParamsAssignment_0_1_0_in_rule__Lambda__Group_0_1__0__Impl28192);
+ rule__Lambda__ParamsAssignment_0_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0_1__0__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group_0_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13898:1: rule__Lambda__Group_0_1__1 : rule__Lambda__Group_0_1__1__Impl ;
+ public final void rule__Lambda__Group_0_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13902:1: ( rule__Lambda__Group_0_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13903:2: rule__Lambda__Group_0_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0_1__1__Impl_in_rule__Lambda__Group_0_1__128222);
+ rule__Lambda__Group_0_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0_1__1"
+
+
+ // $ANTLR start "rule__Lambda__Group_0_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13909:1: rule__Lambda__Group_0_1__1__Impl : ( ( rule__Lambda__Group_0_1_1__0 )* ) ;
+ public final void rule__Lambda__Group_0_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13913:1: ( ( ( rule__Lambda__Group_0_1_1__0 )* ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13914:1: ( ( rule__Lambda__Group_0_1_1__0 )* )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13914:1: ( ( rule__Lambda__Group_0_1_1__0 )* )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13915:1: ( rule__Lambda__Group_0_1_1__0 )*
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getGroup_0_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13916:1: ( rule__Lambda__Group_0_1_1__0 )*
+ loop104:
+ do {
+ int alt104=2;
+ int LA104_0 = input.LA(1);
+
+ if ( (LA104_0==RULE_COMMA) ) {
+ alt104=1;
+ }
+
+
+ switch (alt104) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13916:2: rule__Lambda__Group_0_1_1__0
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0_1_1__0_in_rule__Lambda__Group_0_1__1__Impl28249);
+ rule__Lambda__Group_0_1_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ break loop104;
+ }
+ } while (true);
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getGroup_0_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0_1__1__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group_0_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13930:1: rule__Lambda__Group_0_1_1__0 : rule__Lambda__Group_0_1_1__0__Impl rule__Lambda__Group_0_1_1__1 ;
+ public final void rule__Lambda__Group_0_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13934:1: ( rule__Lambda__Group_0_1_1__0__Impl rule__Lambda__Group_0_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13935:2: rule__Lambda__Group_0_1_1__0__Impl rule__Lambda__Group_0_1_1__1
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0_1_1__0__Impl_in_rule__Lambda__Group_0_1_1__028284);
+ rule__Lambda__Group_0_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Lambda__Group_0_1_1__1_in_rule__Lambda__Group_0_1_1__028287);
+ rule__Lambda__Group_0_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0_1_1__0"
+
+
+ // $ANTLR start "rule__Lambda__Group_0_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13942:1: rule__Lambda__Group_0_1_1__0__Impl : ( RULE_COMMA ) ;
+ public final void rule__Lambda__Group_0_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13946:1: ( ( RULE_COMMA ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13947:1: ( RULE_COMMA )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13947:1: ( RULE_COMMA )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13948:1: RULE_COMMA
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0());
+ }
+ match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_rule__Lambda__Group_0_1_1__0__Impl28314); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__Lambda__Group_0_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13959:1: rule__Lambda__Group_0_1_1__1 : rule__Lambda__Group_0_1_1__1__Impl ;
+ public final void rule__Lambda__Group_0_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13963:1: ( rule__Lambda__Group_0_1_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13964:2: rule__Lambda__Group_0_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Lambda__Group_0_1_1__1__Impl_in_rule__Lambda__Group_0_1_1__128343);
+ rule__Lambda__Group_0_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0_1_1__1"
+
+
+ // $ANTLR start "rule__Lambda__Group_0_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13970:1: rule__Lambda__Group_0_1_1__1__Impl : ( ( rule__Lambda__ParamsAssignment_0_1_1_1 ) ) ;
+ public final void rule__Lambda__Group_0_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13974:1: ( ( ( rule__Lambda__ParamsAssignment_0_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13975:1: ( ( rule__Lambda__ParamsAssignment_0_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13975:1: ( ( rule__Lambda__ParamsAssignment_0_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13976:1: ( rule__Lambda__ParamsAssignment_0_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13977:1: ( rule__Lambda__ParamsAssignment_0_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13977:2: rule__Lambda__ParamsAssignment_0_1_1_1
+ {
+ pushFollow(FOLLOW_rule__Lambda__ParamsAssignment_0_1_1_1_in_rule__Lambda__Group_0_1_1__1__Impl28370);
+ rule__Lambda__ParamsAssignment_0_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getParamsAssignment_0_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__Group_0_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__Param__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13991:1: rule__Param__Group__0 : rule__Param__Group__0__Impl rule__Param__Group__1 ;
+ public final void rule__Param__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13995:1: ( rule__Param__Group__0__Impl rule__Param__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:13996:2: rule__Param__Group__0__Impl rule__Param__Group__1
+ {
+ pushFollow(FOLLOW_rule__Param__Group__0__Impl_in_rule__Param__Group__028404);
+ rule__Param__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Param__Group__1_in_rule__Param__Group__028407);
+ rule__Param__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Group__0"
+
+
+ // $ANTLR start "rule__Param__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14003:1: rule__Param__Group__0__Impl : ( ( rule__Param__Alternatives_0 ) ) ;
+ public final void rule__Param__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14007:1: ( ( ( rule__Param__Alternatives_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14008:1: ( ( rule__Param__Alternatives_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14008:1: ( ( rule__Param__Alternatives_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14009:1: ( rule__Param__Alternatives_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getAlternatives_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14010:1: ( rule__Param__Alternatives_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14010:2: rule__Param__Alternatives_0
+ {
+ pushFollow(FOLLOW_rule__Param__Alternatives_0_in_rule__Param__Group__0__Impl28434);
+ rule__Param__Alternatives_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getAlternatives_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Group__0__Impl"
+
+
+ // $ANTLR start "rule__Param__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14020:1: rule__Param__Group__1 : rule__Param__Group__1__Impl ;
+ public final void rule__Param__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14024:1: ( rule__Param__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14025:2: rule__Param__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Param__Group__1__Impl_in_rule__Param__Group__128464);
+ rule__Param__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Group__1"
+
+
+ // $ANTLR start "rule__Param__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14031:1: rule__Param__Group__1__Impl : ( ( rule__Param__Alternatives_1 )? ) ;
+ public final void rule__Param__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14035:1: ( ( ( rule__Param__Alternatives_1 )? ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14036:1: ( ( rule__Param__Alternatives_1 )? )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14036:1: ( ( rule__Param__Alternatives_1 )? )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14037:1: ( rule__Param__Alternatives_1 )?
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getAlternatives_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14038:1: ( rule__Param__Alternatives_1 )?
+ int alt105=2;
+ int LA105_0 = input.LA(1);
+
+ if ( ((LA105_0>=RULE_ELLIPSIS && LA105_0<=RULE_EQUAL)) ) {
+ alt105=1;
+ }
+ switch (alt105) {
+ case 1 :
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14038:2: rule__Param__Alternatives_1
+ {
+ pushFollow(FOLLOW_rule__Param__Alternatives_1_in_rule__Param__Group__1__Impl28491);
+ rule__Param__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getAlternatives_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Param__Group_1_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14052:1: rule__Param__Group_1_1__0 : rule__Param__Group_1_1__0__Impl rule__Param__Group_1_1__1 ;
+ public final void rule__Param__Group_1_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14056:1: ( rule__Param__Group_1_1__0__Impl rule__Param__Group_1_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14057:2: rule__Param__Group_1_1__0__Impl rule__Param__Group_1_1__1
+ {
+ pushFollow(FOLLOW_rule__Param__Group_1_1__0__Impl_in_rule__Param__Group_1_1__028526);
+ rule__Param__Group_1_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Param__Group_1_1__1_in_rule__Param__Group_1_1__028529);
+ rule__Param__Group_1_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Group_1_1__0"
+
+
+ // $ANTLR start "rule__Param__Group_1_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14064:1: rule__Param__Group_1_1__0__Impl : ( RULE_EQUAL ) ;
+ public final void rule__Param__Group_1_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14068:1: ( ( RULE_EQUAL ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14069:1: ( RULE_EQUAL )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14069:1: ( RULE_EQUAL )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14070:1: RULE_EQUAL
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0());
+ }
+ match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_rule__Param__Group_1_1__0__Impl28556); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Group_1_1__0__Impl"
+
+
+ // $ANTLR start "rule__Param__Group_1_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14081:1: rule__Param__Group_1_1__1 : rule__Param__Group_1_1__1__Impl ;
+ public final void rule__Param__Group_1_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14085:1: ( rule__Param__Group_1_1__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14086:2: rule__Param__Group_1_1__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Param__Group_1_1__1__Impl_in_rule__Param__Group_1_1__128585);
+ rule__Param__Group_1_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Group_1_1__1"
+
+
+ // $ANTLR start "rule__Param__Group_1_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14092:1: rule__Param__Group_1_1__1__Impl : ( ( rule__Param__DefaultValueAssignment_1_1_1 ) ) ;
+ public final void rule__Param__Group_1_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14096:1: ( ( ( rule__Param__DefaultValueAssignment_1_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14097:1: ( ( rule__Param__DefaultValueAssignment_1_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14097:1: ( ( rule__Param__DefaultValueAssignment_1_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14098:1: ( rule__Param__DefaultValueAssignment_1_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getDefaultValueAssignment_1_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14099:1: ( rule__Param__DefaultValueAssignment_1_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14099:2: rule__Param__DefaultValueAssignment_1_1_1
+ {
+ pushFollow(FOLLOW_rule__Param__DefaultValueAssignment_1_1_1_in_rule__Param__Group_1_1__1__Impl28612);
+ rule__Param__DefaultValueAssignment_1_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getDefaultValueAssignment_1_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__Group_1_1__1__Impl"
+
+
+ // $ANTLR start "rule__NumberLiteral__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14113:1: rule__NumberLiteral__Group__0 : rule__NumberLiteral__Group__0__Impl rule__NumberLiteral__Group__1 ;
+ public final void rule__NumberLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14117:1: ( rule__NumberLiteral__Group__0__Impl rule__NumberLiteral__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14118:2: rule__NumberLiteral__Group__0__Impl rule__NumberLiteral__Group__1
+ {
+ pushFollow(FOLLOW_rule__NumberLiteral__Group__0__Impl_in_rule__NumberLiteral__Group__028646);
+ rule__NumberLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__NumberLiteral__Group__1_in_rule__NumberLiteral__Group__028649);
+ rule__NumberLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NumberLiteral__Group__0"
+
+
+ // $ANTLR start "rule__NumberLiteral__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14125:1: rule__NumberLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__NumberLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14129:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14130:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14130:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14131:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14132:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14134:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NumberLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__NumberLiteral__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14144:1: rule__NumberLiteral__Group__1 : rule__NumberLiteral__Group__1__Impl ;
+ public final void rule__NumberLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14148:1: ( rule__NumberLiteral__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14149:2: rule__NumberLiteral__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__NumberLiteral__Group__1__Impl_in_rule__NumberLiteral__Group__128707);
+ rule__NumberLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NumberLiteral__Group__1"
+
+
+ // $ANTLR start "rule__NumberLiteral__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14155:1: rule__NumberLiteral__Group__1__Impl : ( RULE_NUMBER ) ;
+ public final void rule__NumberLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14159:1: ( ( RULE_NUMBER ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14160:1: ( RULE_NUMBER )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14160:1: ( RULE_NUMBER )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14161:1: RULE_NUMBER
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1());
+ }
+ match(input,RULE_NUMBER,FOLLOW_RULE_NUMBER_in_rule__NumberLiteral__Group__1__Impl28734); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NumberLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__StringLiteral__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14176:1: rule__StringLiteral__Group__0 : rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 ;
+ public final void rule__StringLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14180:1: ( rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14181:2: rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1
+ {
+ pushFollow(FOLLOW_rule__StringLiteral__Group__0__Impl_in_rule__StringLiteral__Group__028767);
+ rule__StringLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__StringLiteral__Group__1_in_rule__StringLiteral__Group__028770);
+ rule__StringLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__StringLiteral__Group__0"
+
+
+ // $ANTLR start "rule__StringLiteral__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14188:1: rule__StringLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__StringLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14192:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14193:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14193:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14194:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14195:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14197:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__StringLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__StringLiteral__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14207:1: rule__StringLiteral__Group__1 : rule__StringLiteral__Group__1__Impl ;
+ public final void rule__StringLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14211:1: ( rule__StringLiteral__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14212:2: rule__StringLiteral__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__StringLiteral__Group__1__Impl_in_rule__StringLiteral__Group__128828);
+ rule__StringLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__StringLiteral__Group__1"
+
+
+ // $ANTLR start "rule__StringLiteral__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14218:1: rule__StringLiteral__Group__1__Impl : ( RULE_STRING ) ;
+ public final void rule__StringLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14222:1: ( ( RULE_STRING ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14223:1: ( RULE_STRING )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14223:1: ( RULE_STRING )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14224:1: RULE_STRING
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1());
+ }
+ match(input,RULE_STRING,FOLLOW_RULE_STRING_in_rule__StringLiteral__Group__1__Impl28855); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__StringLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__BoolLiteral__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14239:1: rule__BoolLiteral__Group__0 : rule__BoolLiteral__Group__0__Impl rule__BoolLiteral__Group__1 ;
+ public final void rule__BoolLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14243:1: ( rule__BoolLiteral__Group__0__Impl rule__BoolLiteral__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14244:2: rule__BoolLiteral__Group__0__Impl rule__BoolLiteral__Group__1
+ {
+ pushFollow(FOLLOW_rule__BoolLiteral__Group__0__Impl_in_rule__BoolLiteral__Group__028888);
+ rule__BoolLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__BoolLiteral__Group__1_in_rule__BoolLiteral__Group__028891);
+ rule__BoolLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__BoolLiteral__Group__0"
+
+
+ // $ANTLR start "rule__BoolLiteral__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14251:1: rule__BoolLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__BoolLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14255:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14256:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14256:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14257:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14258:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14260:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__BoolLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__BoolLiteral__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14270:1: rule__BoolLiteral__Group__1 : rule__BoolLiteral__Group__1__Impl ;
+ public final void rule__BoolLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14274:1: ( rule__BoolLiteral__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14275:2: rule__BoolLiteral__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__BoolLiteral__Group__1__Impl_in_rule__BoolLiteral__Group__128949);
+ rule__BoolLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__BoolLiteral__Group__1"
+
+
+ // $ANTLR start "rule__BoolLiteral__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14281:1: rule__BoolLiteral__Group__1__Impl : ( RULE_BOOL ) ;
+ public final void rule__BoolLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14285:1: ( ( RULE_BOOL ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14286:1: ( RULE_BOOL )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14286:1: ( RULE_BOOL )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14287:1: RULE_BOOL
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1());
+ }
+ match(input,RULE_BOOL,FOLLOW_RULE_BOOL_in_rule__BoolLiteral__Group__1__Impl28976); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__BoolLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__JSLiteral__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14302:1: rule__JSLiteral__Group__0 : rule__JSLiteral__Group__0__Impl rule__JSLiteral__Group__1 ;
+ public final void rule__JSLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14306:1: ( rule__JSLiteral__Group__0__Impl rule__JSLiteral__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14307:2: rule__JSLiteral__Group__0__Impl rule__JSLiteral__Group__1
+ {
+ pushFollow(FOLLOW_rule__JSLiteral__Group__0__Impl_in_rule__JSLiteral__Group__029009);
+ rule__JSLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__JSLiteral__Group__1_in_rule__JSLiteral__Group__029012);
+ rule__JSLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JSLiteral__Group__0"
+
+
+ // $ANTLR start "rule__JSLiteral__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14314:1: rule__JSLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__JSLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14318:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14319:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14319:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14320:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJSLiteralAccess().getJSLiteralAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14321:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14323:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJSLiteralAccess().getJSLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JSLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__JSLiteral__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14333:1: rule__JSLiteral__Group__1 : rule__JSLiteral__Group__1__Impl ;
+ public final void rule__JSLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14337:1: ( rule__JSLiteral__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14338:2: rule__JSLiteral__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__JSLiteral__Group__1__Impl_in_rule__JSLiteral__Group__129070);
+ rule__JSLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JSLiteral__Group__1"
+
+
+ // $ANTLR start "rule__JSLiteral__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14344:1: rule__JSLiteral__Group__1__Impl : ( RULE_JS ) ;
+ public final void rule__JSLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14348:1: ( ( RULE_JS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14349:1: ( RULE_JS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14349:1: ( RULE_JS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14350:1: RULE_JS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1());
+ }
+ match(input,RULE_JS,FOLLOW_RULE_JS_in_rule__JSLiteral__Group__1__Impl29097); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__JSLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__RegexLiteral__Group__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14365:1: rule__RegexLiteral__Group__0 : rule__RegexLiteral__Group__0__Impl rule__RegexLiteral__Group__1 ;
+ public final void rule__RegexLiteral__Group__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14369:1: ( rule__RegexLiteral__Group__0__Impl rule__RegexLiteral__Group__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14370:2: rule__RegexLiteral__Group__0__Impl rule__RegexLiteral__Group__1
+ {
+ pushFollow(FOLLOW_rule__RegexLiteral__Group__0__Impl_in_rule__RegexLiteral__Group__029130);
+ rule__RegexLiteral__Group__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__RegexLiteral__Group__1_in_rule__RegexLiteral__Group__029133);
+ rule__RegexLiteral__Group__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RegexLiteral__Group__0"
+
+
+ // $ANTLR start "rule__RegexLiteral__Group__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14377:1: rule__RegexLiteral__Group__0__Impl : ( () ) ;
+ public final void rule__RegexLiteral__Group__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14381:1: ( ( () ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14382:1: ( () )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14382:1: ( () )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14383:1: ()
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14384:1: ()
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14386:1:
+ {
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RegexLiteral__Group__0__Impl"
+
+
+ // $ANTLR start "rule__RegexLiteral__Group__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14396:1: rule__RegexLiteral__Group__1 : rule__RegexLiteral__Group__1__Impl ;
+ public final void rule__RegexLiteral__Group__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14400:1: ( rule__RegexLiteral__Group__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14401:2: rule__RegexLiteral__Group__1__Impl
+ {
+ pushFollow(FOLLOW_rule__RegexLiteral__Group__1__Impl_in_rule__RegexLiteral__Group__129191);
+ rule__RegexLiteral__Group__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RegexLiteral__Group__1"
+
+
+ // $ANTLR start "rule__RegexLiteral__Group__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14407:1: rule__RegexLiteral__Group__1__Impl : ( RULE_REGEX ) ;
+ public final void rule__RegexLiteral__Group__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14411:1: ( ( RULE_REGEX ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14412:1: ( RULE_REGEX )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14412:1: ( RULE_REGEX )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14413:1: RULE_REGEX
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1());
+ }
+ match(input,RULE_REGEX,FOLLOW_RULE_REGEX_in_rule__RegexLiteral__Group__1__Impl29218); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RegexLiteral__Group__1__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14428:1: rule__Parenthetical__Group_0__0 : rule__Parenthetical__Group_0__0__Impl rule__Parenthetical__Group_0__1 ;
+ public final void rule__Parenthetical__Group_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14432:1: ( rule__Parenthetical__Group_0__0__Impl rule__Parenthetical__Group_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14433:2: rule__Parenthetical__Group_0__0__Impl rule__Parenthetical__Group_0__1
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0__0__Impl_in_rule__Parenthetical__Group_0__029251);
+ rule__Parenthetical__Group_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0__1_in_rule__Parenthetical__Group_0__029254);
+ rule__Parenthetical__Group_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0__0"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14440:1: rule__Parenthetical__Group_0__0__Impl : ( ( rule__Parenthetical__Group_0_0__0 ) ) ;
+ public final void rule__Parenthetical__Group_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14444:1: ( ( ( rule__Parenthetical__Group_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14445:1: ( ( rule__Parenthetical__Group_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14445:1: ( ( rule__Parenthetical__Group_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14446:1: ( rule__Parenthetical__Group_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getGroup_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14447:1: ( rule__Parenthetical__Group_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14447:2: rule__Parenthetical__Group_0_0__0
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0_0__0_in_rule__Parenthetical__Group_0__0__Impl29281);
+ rule__Parenthetical__Group_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getGroup_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0__0__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14457:1: rule__Parenthetical__Group_0__1 : rule__Parenthetical__Group_0__1__Impl rule__Parenthetical__Group_0__2 ;
+ public final void rule__Parenthetical__Group_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14461:1: ( rule__Parenthetical__Group_0__1__Impl rule__Parenthetical__Group_0__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14462:2: rule__Parenthetical__Group_0__1__Impl rule__Parenthetical__Group_0__2
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0__1__Impl_in_rule__Parenthetical__Group_0__129311);
+ rule__Parenthetical__Group_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0__2_in_rule__Parenthetical__Group_0__129314);
+ rule__Parenthetical__Group_0__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0__1"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14469:1: rule__Parenthetical__Group_0__1__Impl : ( ( rule__Parenthetical__ContentAssignment_0_1 ) ) ;
+ public final void rule__Parenthetical__Group_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14473:1: ( ( ( rule__Parenthetical__ContentAssignment_0_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14474:1: ( ( rule__Parenthetical__ContentAssignment_0_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14474:1: ( ( rule__Parenthetical__ContentAssignment_0_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14475:1: ( rule__Parenthetical__ContentAssignment_0_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getContentAssignment_0_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14476:1: ( rule__Parenthetical__ContentAssignment_0_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14476:2: rule__Parenthetical__ContentAssignment_0_1
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__ContentAssignment_0_1_in_rule__Parenthetical__Group_0__1__Impl29341);
+ rule__Parenthetical__ContentAssignment_0_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getContentAssignment_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0__1__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14486:1: rule__Parenthetical__Group_0__2 : rule__Parenthetical__Group_0__2__Impl rule__Parenthetical__Group_0__3 ;
+ public final void rule__Parenthetical__Group_0__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14490:1: ( rule__Parenthetical__Group_0__2__Impl rule__Parenthetical__Group_0__3 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14491:2: rule__Parenthetical__Group_0__2__Impl rule__Parenthetical__Group_0__3
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0__2__Impl_in_rule__Parenthetical__Group_0__229371);
+ rule__Parenthetical__Group_0__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0__3_in_rule__Parenthetical__Group_0__229374);
+ rule__Parenthetical__Group_0__3();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0__2"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14498:1: rule__Parenthetical__Group_0__2__Impl : ( RULE_OUTDENT ) ;
+ public final void rule__Parenthetical__Group_0__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14502:1: ( ( RULE_OUTDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14503:1: ( RULE_OUTDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14503:1: ( RULE_OUTDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14504:1: RULE_OUTDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2());
+ }
+ match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rule__Parenthetical__Group_0__2__Impl29401); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0__2__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0__3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14515:1: rule__Parenthetical__Group_0__3 : rule__Parenthetical__Group_0__3__Impl ;
+ public final void rule__Parenthetical__Group_0__3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14519:1: ( rule__Parenthetical__Group_0__3__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14520:2: rule__Parenthetical__Group_0__3__Impl
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0__3__Impl_in_rule__Parenthetical__Group_0__329430);
+ rule__Parenthetical__Group_0__3__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0__3"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0__3__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14526:1: rule__Parenthetical__Group_0__3__Impl : ( RULE_RPAREN ) ;
+ public final void rule__Parenthetical__Group_0__3__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14530:1: ( ( RULE_RPAREN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14531:1: ( RULE_RPAREN )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14531:1: ( RULE_RPAREN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14532:1: RULE_RPAREN
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3());
+ }
+ match(input,RULE_RPAREN,FOLLOW_RULE_RPAREN_in_rule__Parenthetical__Group_0__3__Impl29457); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0__3__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14551:1: rule__Parenthetical__Group_0_0__0 : rule__Parenthetical__Group_0_0__0__Impl ;
+ public final void rule__Parenthetical__Group_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14555:1: ( rule__Parenthetical__Group_0_0__0__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14556:2: rule__Parenthetical__Group_0_0__0__Impl
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0_0__0__Impl_in_rule__Parenthetical__Group_0_0__029494);
+ rule__Parenthetical__Group_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0_0__0"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14562:1: rule__Parenthetical__Group_0_0__0__Impl : ( ( rule__Parenthetical__Group_0_0_0__0 ) ) ;
+ public final void rule__Parenthetical__Group_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14566:1: ( ( ( rule__Parenthetical__Group_0_0_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14567:1: ( ( rule__Parenthetical__Group_0_0_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14567:1: ( ( rule__Parenthetical__Group_0_0_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14568:1: ( rule__Parenthetical__Group_0_0_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getGroup_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14569:1: ( rule__Parenthetical__Group_0_0_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14569:2: rule__Parenthetical__Group_0_0_0__0
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0_0_0__0_in_rule__Parenthetical__Group_0_0__0__Impl29521);
+ rule__Parenthetical__Group_0_0_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getGroup_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0_0_0__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14581:1: rule__Parenthetical__Group_0_0_0__0 : rule__Parenthetical__Group_0_0_0__0__Impl rule__Parenthetical__Group_0_0_0__1 ;
+ public final void rule__Parenthetical__Group_0_0_0__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14585:1: ( rule__Parenthetical__Group_0_0_0__0__Impl rule__Parenthetical__Group_0_0_0__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14586:2: rule__Parenthetical__Group_0_0_0__0__Impl rule__Parenthetical__Group_0_0_0__1
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0_0_0__0__Impl_in_rule__Parenthetical__Group_0_0_0__029553);
+ rule__Parenthetical__Group_0_0_0__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0_0_0__1_in_rule__Parenthetical__Group_0_0_0__029556);
+ rule__Parenthetical__Group_0_0_0__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0_0_0__0"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0_0_0__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14593:1: rule__Parenthetical__Group_0_0_0__0__Impl : ( RULE_LPAREN ) ;
+ public final void rule__Parenthetical__Group_0_0_0__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14597:1: ( ( RULE_LPAREN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14598:1: ( RULE_LPAREN )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14598:1: ( RULE_LPAREN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14599:1: RULE_LPAREN
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0());
+ }
+ match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_rule__Parenthetical__Group_0_0_0__0__Impl29583); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0_0_0__0__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0_0_0__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14610:1: rule__Parenthetical__Group_0_0_0__1 : rule__Parenthetical__Group_0_0_0__1__Impl ;
+ public final void rule__Parenthetical__Group_0_0_0__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14614:1: ( rule__Parenthetical__Group_0_0_0__1__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14615:2: rule__Parenthetical__Group_0_0_0__1__Impl
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_0_0_0__1__Impl_in_rule__Parenthetical__Group_0_0_0__129612);
+ rule__Parenthetical__Group_0_0_0__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0_0_0__1"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_0_0_0__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14621:1: rule__Parenthetical__Group_0_0_0__1__Impl : ( RULE_INDENT ) ;
+ public final void rule__Parenthetical__Group_0_0_0__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14625:1: ( ( RULE_INDENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14626:1: ( RULE_INDENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14626:1: ( RULE_INDENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14627:1: RULE_INDENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1());
+ }
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rule__Parenthetical__Group_0_0_0__1__Impl29639); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_0_0_0__1__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_1__0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14642:1: rule__Parenthetical__Group_1__0 : rule__Parenthetical__Group_1__0__Impl rule__Parenthetical__Group_1__1 ;
+ public final void rule__Parenthetical__Group_1__0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14646:1: ( rule__Parenthetical__Group_1__0__Impl rule__Parenthetical__Group_1__1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14647:2: rule__Parenthetical__Group_1__0__Impl rule__Parenthetical__Group_1__1
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_1__0__Impl_in_rule__Parenthetical__Group_1__029672);
+ rule__Parenthetical__Group_1__0__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Parenthetical__Group_1__1_in_rule__Parenthetical__Group_1__029675);
+ rule__Parenthetical__Group_1__1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_1__0"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_1__0__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14654:1: rule__Parenthetical__Group_1__0__Impl : ( ( RULE_LPAREN ) ) ;
+ public final void rule__Parenthetical__Group_1__0__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14658:1: ( ( ( RULE_LPAREN ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14659:1: ( ( RULE_LPAREN ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14659:1: ( ( RULE_LPAREN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14660:1: ( RULE_LPAREN )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14661:1: ( RULE_LPAREN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14661:3: RULE_LPAREN
+ {
+ match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_rule__Parenthetical__Group_1__0__Impl29703); if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_1__0__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_1__1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14671:1: rule__Parenthetical__Group_1__1 : rule__Parenthetical__Group_1__1__Impl rule__Parenthetical__Group_1__2 ;
+ public final void rule__Parenthetical__Group_1__1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14675:1: ( rule__Parenthetical__Group_1__1__Impl rule__Parenthetical__Group_1__2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14676:2: rule__Parenthetical__Group_1__1__Impl rule__Parenthetical__Group_1__2
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_1__1__Impl_in_rule__Parenthetical__Group_1__129733);
+ rule__Parenthetical__Group_1__1__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+ pushFollow(FOLLOW_rule__Parenthetical__Group_1__2_in_rule__Parenthetical__Group_1__129736);
+ rule__Parenthetical__Group_1__2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_1__1"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_1__1__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14683:1: rule__Parenthetical__Group_1__1__Impl : ( ( rule__Parenthetical__ContentAssignment_1_1 ) ) ;
+ public final void rule__Parenthetical__Group_1__1__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14687:1: ( ( ( rule__Parenthetical__ContentAssignment_1_1 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14688:1: ( ( rule__Parenthetical__ContentAssignment_1_1 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14688:1: ( ( rule__Parenthetical__ContentAssignment_1_1 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14689:1: ( rule__Parenthetical__ContentAssignment_1_1 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getContentAssignment_1_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14690:1: ( rule__Parenthetical__ContentAssignment_1_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14690:2: rule__Parenthetical__ContentAssignment_1_1
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__ContentAssignment_1_1_in_rule__Parenthetical__Group_1__1__Impl29763);
+ rule__Parenthetical__ContentAssignment_1_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getContentAssignment_1_1());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_1__1__Impl"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_1__2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14700:1: rule__Parenthetical__Group_1__2 : rule__Parenthetical__Group_1__2__Impl ;
+ public final void rule__Parenthetical__Group_1__2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14704:1: ( rule__Parenthetical__Group_1__2__Impl )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14705:2: rule__Parenthetical__Group_1__2__Impl
+ {
+ pushFollow(FOLLOW_rule__Parenthetical__Group_1__2__Impl_in_rule__Parenthetical__Group_1__229793);
+ rule__Parenthetical__Group_1__2__Impl();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_1__2"
+
+
+ // $ANTLR start "rule__Parenthetical__Group_1__2__Impl"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14711:1: rule__Parenthetical__Group_1__2__Impl : ( RULE_RPAREN ) ;
+ public final void rule__Parenthetical__Group_1__2__Impl() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14715:1: ( ( RULE_RPAREN ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14716:1: ( RULE_RPAREN )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14716:1: ( RULE_RPAREN )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14717:1: RULE_RPAREN
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2());
+ }
+ match(input,RULE_RPAREN,FOLLOW_RULE_RPAREN_in_rule__Parenthetical__Group_1__2__Impl29820); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__Group_1__2__Impl"
+
+
+ // $ANTLR start "rule__Cakefile__TasksAssignment"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14735:1: rule__Cakefile__TasksAssignment : ( ruleTaskDeclaration ) ;
+ public final void rule__Cakefile__TasksAssignment() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14739:1: ( ( ruleTaskDeclaration ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14740:1: ( ruleTaskDeclaration )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14740:1: ( ruleTaskDeclaration )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14741:1: ruleTaskDeclaration
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCakefileAccess().getTasksTaskDeclarationParserRuleCall_0());
+ }
+ pushFollow(FOLLOW_ruleTaskDeclaration_in_rule__Cakefile__TasksAssignment29860);
+ ruleTaskDeclaration();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCakefileAccess().getTasksTaskDeclarationParserRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Cakefile__TasksAssignment"
+
+
+ // $ANTLR start "rule__TaskDeclaration__NameAssignment_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14750:1: rule__TaskDeclaration__NameAssignment_2 : ( ruleStringLiteral ) ;
+ public final void rule__TaskDeclaration__NameAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14754:1: ( ( ruleStringLiteral ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14755:1: ( ruleStringLiteral )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14755:1: ( ruleStringLiteral )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14756:1: ruleStringLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getNameStringLiteralParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_rule__TaskDeclaration__NameAssignment_229891);
+ ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getNameStringLiteralParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__NameAssignment_2"
+
+
+ // $ANTLR start "rule__TaskDeclaration__DescriptionAssignment_4"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14765:1: rule__TaskDeclaration__DescriptionAssignment_4 : ( ruleStringLiteral ) ;
+ public final void rule__TaskDeclaration__DescriptionAssignment_4() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14769:1: ( ( ruleStringLiteral ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14770:1: ( ruleStringLiteral )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14770:1: ( ruleStringLiteral )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14771:1: ruleStringLiteral
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getDescriptionStringLiteralParserRuleCall_4_0());
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_rule__TaskDeclaration__DescriptionAssignment_429922);
+ ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getDescriptionStringLiteralParserRuleCall_4_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__DescriptionAssignment_4"
+
+
+ // $ANTLR start "rule__TaskDeclaration__OptionsAssignment_6_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14780:1: rule__TaskDeclaration__OptionsAssignment_6_1 : ( ruleId ) ;
+ public final void rule__TaskDeclaration__OptionsAssignment_6_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14784:1: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14785:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14785:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14786:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getOptionsIdParserRuleCall_6_1_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__TaskDeclaration__OptionsAssignment_6_129953);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getOptionsIdParserRuleCall_6_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__OptionsAssignment_6_1"
+
+
+ // $ANTLR start "rule__TaskDeclaration__BodyAssignment_8"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14795:1: rule__TaskDeclaration__BodyAssignment_8 : ( ruleBlock ) ;
+ public final void rule__TaskDeclaration__BodyAssignment_8() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14799:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14800:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14800:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14801:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getTaskDeclarationAccess().getBodyBlockParserRuleCall_8_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__TaskDeclaration__BodyAssignment_829984);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getTaskDeclarationAccess().getBodyBlockParserRuleCall_8_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__TaskDeclaration__BodyAssignment_8"
+
+
+ // $ANTLR start "rule__Body__LinesAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14810:1: rule__Body__LinesAssignment_0 : ( ruleLine ) ;
+ public final void rule__Body__LinesAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14814:1: ( ( ruleLine ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14815:1: ( ruleLine )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14815:1: ( ruleLine )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14816:1: ruleLine
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleLine_in_rule__Body__LinesAssignment_030015);
+ ruleLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__LinesAssignment_0"
+
+
+ // $ANTLR start "rule__Body__LinesAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14825:1: rule__Body__LinesAssignment_1_1 : ( ruleLine ) ;
+ public final void rule__Body__LinesAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14829:1: ( ( ruleLine ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14830:1: ( ruleLine )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14830:1: ( ruleLine )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14831:1: ruleLine
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleLine_in_rule__Body__LinesAssignment_1_130046);
+ ruleLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Body__LinesAssignment_1_1"
+
+
+ // $ANTLR start "rule__Stmt__StatementAssignment_5"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14840:1: rule__Stmt__StatementAssignment_5 : ( RULE_STATEMENT ) ;
+ public final void rule__Stmt__StatementAssignment_5() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14844:1: ( ( RULE_STATEMENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14845:1: ( RULE_STATEMENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14845:1: ( RULE_STATEMENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14846:1: RULE_STATEMENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0());
+ }
+ match(input,RULE_STATEMENT,FOLLOW_RULE_STATEMENT_in_rule__Stmt__StatementAssignment_530077); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Stmt__StatementAssignment_5"
+
+
+ // $ANTLR start "rule__Comment__CommentAssignment"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14855:1: rule__Comment__CommentAssignment : ( RULE_HERECOMMENT ) ;
+ public final void rule__Comment__CommentAssignment() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14859:1: ( ( RULE_HERECOMMENT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14860:1: ( RULE_HERECOMMENT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14860:1: ( RULE_HERECOMMENT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14861:1: RULE_HERECOMMENT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0());
+ }
+ match(input,RULE_HERECOMMENT,FOLLOW_RULE_HERECOMMENT_in_rule__Comment__CommentAssignment30108); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Comment__CommentAssignment"
+
+
+ // $ANTLR start "rule__RequireStmt__ImportedNamespaceAssignment_0_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14870:1: rule__RequireStmt__ImportedNamespaceAssignment_0_0_0 : ( ruleId ) ;
+ public final void rule__RequireStmt__ImportedNamespaceAssignment_0_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14874:1: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14875:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14875:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14876:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__RequireStmt__ImportedNamespaceAssignment_0_0_030139);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__ImportedNamespaceAssignment_0_0_0"
+
+
+ // $ANTLR start "rule__RequireStmt__UriAssignment_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14885:1: rule__RequireStmt__UriAssignment_2 : ( RULE_STRING ) ;
+ public final void rule__RequireStmt__UriAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14889:1: ( ( RULE_STRING ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14890:1: ( RULE_STRING )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14890:1: ( RULE_STRING )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14891:1: RULE_STRING
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0());
+ }
+ match(input,RULE_STRING,FOLLOW_RULE_STRING_in_rule__RequireStmt__UriAssignment_230170); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RequireStmt__UriAssignment_2"
+
+
+ // $ANTLR start "rule__ReturnStmt__ExpressionAssignment_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14900:1: rule__ReturnStmt__ExpressionAssignment_2 : ( ruleExpression ) ;
+ public final void rule__ReturnStmt__ExpressionAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14904:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14905:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14905:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14906:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ReturnStmt__ExpressionAssignment_230201);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__ExpressionAssignment_2"
+
+
+ // $ANTLR start "rule__ReturnStmt__ConditionAssignment_3_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14915:1: rule__ReturnStmt__ConditionAssignment_3_1 : ( ruleExpression ) ;
+ public final void rule__ReturnStmt__ConditionAssignment_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14919:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14920:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14920:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14921:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ReturnStmt__ConditionAssignment_3_130232);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ReturnStmt__ConditionAssignment_3_1"
+
+
+ // $ANTLR start "rule__ThrowStmt__ExpAssignment_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14930:1: rule__ThrowStmt__ExpAssignment_1 : ( ruleExpression ) ;
+ public final void rule__ThrowStmt__ExpAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14934:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14935:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14935:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14936:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ThrowStmt__ExpAssignment_130263);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ThrowStmt__ExpAssignment_1"
+
+
+ // $ANTLR start "rule__ClassDeclaration__BodyAssignment_2_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14945:1: rule__ClassDeclaration__BodyAssignment_2_0 : ( ruleBlock ) ;
+ public final void rule__ClassDeclaration__BodyAssignment_2_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14949:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14950:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14950:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14951:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__ClassDeclaration__BodyAssignment_2_030294);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__BodyAssignment_2_0"
+
+
+ // $ANTLR start "rule__ClassDeclaration__ExtendAssignment_2_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14960:1: rule__ClassDeclaration__ExtendAssignment_2_1_1 : ( ruleSuperClass ) ;
+ public final void rule__ClassDeclaration__ExtendAssignment_2_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14964:1: ( ( ruleSuperClass ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14965:1: ( ruleSuperClass )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14965:1: ( ruleSuperClass )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14966:1: ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_rule__ClassDeclaration__ExtendAssignment_2_1_130325);
+ ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__ExtendAssignment_2_1_1"
+
+
+ // $ANTLR start "rule__ClassDeclaration__BodyAssignment_2_1_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14975:1: rule__ClassDeclaration__BodyAssignment_2_1_2 : ( ruleBlock ) ;
+ public final void rule__ClassDeclaration__BodyAssignment_2_1_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14979:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14980:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14980:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14981:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__ClassDeclaration__BodyAssignment_2_1_230356);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__BodyAssignment_2_1_2"
+
+
+ // $ANTLR start "rule__ClassDeclaration__NameAssignment_2_2_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14990:1: rule__ClassDeclaration__NameAssignment_2_2_0 : ( ( rule__ClassDeclaration__NameAlternatives_2_2_0_0 ) ) ;
+ public final void rule__ClassDeclaration__NameAssignment_2_2_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14994:1: ( ( ( rule__ClassDeclaration__NameAlternatives_2_2_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14995:1: ( ( rule__ClassDeclaration__NameAlternatives_2_2_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14995:1: ( ( rule__ClassDeclaration__NameAlternatives_2_2_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14996:1: ( rule__ClassDeclaration__NameAlternatives_2_2_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getNameAlternatives_2_2_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14997:1: ( rule__ClassDeclaration__NameAlternatives_2_2_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:14997:2: rule__ClassDeclaration__NameAlternatives_2_2_0_0
+ {
+ pushFollow(FOLLOW_rule__ClassDeclaration__NameAlternatives_2_2_0_0_in_rule__ClassDeclaration__NameAssignment_2_2_030387);
+ rule__ClassDeclaration__NameAlternatives_2_2_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getNameAlternatives_2_2_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__NameAssignment_2_2_0"
+
+
+ // $ANTLR start "rule__ClassDeclaration__ExtendAssignment_2_2_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15006:1: rule__ClassDeclaration__ExtendAssignment_2_2_1_1 : ( ruleSuperClass ) ;
+ public final void rule__ClassDeclaration__ExtendAssignment_2_2_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15010:1: ( ( ruleSuperClass ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15011:1: ( ruleSuperClass )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15011:1: ( ruleSuperClass )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15012:1: ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_rule__ClassDeclaration__ExtendAssignment_2_2_1_130420);
+ ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__ExtendAssignment_2_2_1_1"
+
+
+ // $ANTLR start "rule__ClassDeclaration__BodyAssignment_2_2_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15021:1: rule__ClassDeclaration__BodyAssignment_2_2_2 : ( ruleBlock ) ;
+ public final void rule__ClassDeclaration__BodyAssignment_2_2_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15025:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15026:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15026:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15027:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__ClassDeclaration__BodyAssignment_2_2_230451);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ClassDeclaration__BodyAssignment_2_2_2"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__ExtendAssignment_2_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15036:1: rule__AssignedClassDeclaration__ExtendAssignment_2_0_1 : ( ruleSuperClass ) ;
+ public final void rule__AssignedClassDeclaration__ExtendAssignment_2_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15040:1: ( ( ruleSuperClass ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15041:1: ( ruleSuperClass )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15041:1: ( ruleSuperClass )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15042:1: ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_rule__AssignedClassDeclaration__ExtendAssignment_2_0_130482);
+ ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__ExtendAssignment_2_0_1"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__BodyAssignment_2_0_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15051:1: rule__AssignedClassDeclaration__BodyAssignment_2_0_2 : ( ruleBlock ) ;
+ public final void rule__AssignedClassDeclaration__BodyAssignment_2_0_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15055:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15056:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15056:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15057:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__AssignedClassDeclaration__BodyAssignment_2_0_230513);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__BodyAssignment_2_0_2"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__NameAssignment_2_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15066:1: rule__AssignedClassDeclaration__NameAssignment_2_1_0 : ( ( rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0 ) ) ;
+ public final void rule__AssignedClassDeclaration__NameAssignment_2_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15070:1: ( ( ( rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15071:1: ( ( rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15071:1: ( ( rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15072:1: ( rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getNameAlternatives_2_1_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15073:1: ( rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15073:2: rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0
+ {
+ pushFollow(FOLLOW_rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0_in_rule__AssignedClassDeclaration__NameAssignment_2_1_030544);
+ rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getNameAlternatives_2_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__NameAssignment_2_1_0"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15082:1: rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1 : ( ruleSuperClass ) ;
+ public final void rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15086:1: ( ( ruleSuperClass ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15087:1: ( ruleSuperClass )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15087:1: ( ruleSuperClass )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15088:1: ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_130577);
+ ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1"
+
+
+ // $ANTLR start "rule__AssignedClassDeclaration__BodyAssignment_2_1_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15097:1: rule__AssignedClassDeclaration__BodyAssignment_2_1_2 : ( ruleBlock ) ;
+ public final void rule__AssignedClassDeclaration__BodyAssignment_2_1_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15101:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15102:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15102:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15103:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__AssignedClassDeclaration__BodyAssignment_2_1_230608);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignedClassDeclaration__BodyAssignment_2_1_2"
+
+
+ // $ANTLR start "rule__Postfix__ConditionAssignment_1_0_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15112:1: rule__Postfix__ConditionAssignment_1_0_2 : ( ruleExpression ) ;
+ public final void rule__Postfix__ConditionAssignment_1_0_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15116:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15117:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15117:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15118:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Postfix__ConditionAssignment_1_0_230639);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__ConditionAssignment_1_0_2"
+
+
+ // $ANTLR start "rule__Postfix__BodyAssignment_1_1_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15127:1: rule__Postfix__BodyAssignment_1_1_2 : ( ruleForBody ) ;
+ public final void rule__Postfix__BodyAssignment_1_1_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15131:1: ( ( ruleForBody ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15132:1: ( ruleForBody )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15132:1: ( ruleForBody )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15133:1: ruleForBody
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0());
+ }
+ pushFollow(FOLLOW_ruleForBody_in_rule__Postfix__BodyAssignment_1_1_230670);
+ ruleForBody();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__BodyAssignment_1_1_2"
+
+
+ // $ANTLR start "rule__Postfix__BodyAssignment_1_2_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15142:1: rule__Postfix__BodyAssignment_1_2_2 : ( ruleExpression ) ;
+ public final void rule__Postfix__BodyAssignment_1_2_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15146:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15147:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15147:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15148:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Postfix__BodyAssignment_1_2_230701);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__BodyAssignment_1_2_2"
+
+
+ // $ANTLR start "rule__Postfix__WhenAssignment_1_2_3_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15157:1: rule__Postfix__WhenAssignment_1_2_3_1 : ( ruleExpression ) ;
+ public final void rule__Postfix__WhenAssignment_1_2_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15161:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15162:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15162:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15163:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Postfix__WhenAssignment_1_2_3_130732);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__WhenAssignment_1_2_3_1"
+
+
+ // $ANTLR start "rule__Postfix__BodyAssignment_1_3_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15172:1: rule__Postfix__BodyAssignment_1_3_2 : ( ruleExpression ) ;
+ public final void rule__Postfix__BodyAssignment_1_3_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15176:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15177:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15177:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15178:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Postfix__BodyAssignment_1_3_230763);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__BodyAssignment_1_3_2"
+
+
+ // $ANTLR start "rule__Postfix__WhenAssignment_1_3_3_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15187:1: rule__Postfix__WhenAssignment_1_3_3_1 : ( ruleExpression ) ;
+ public final void rule__Postfix__WhenAssignment_1_3_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15191:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15192:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15192:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15193:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Postfix__WhenAssignment_1_3_3_130794);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Postfix__WhenAssignment_1_3_3_1"
+
+
+ // $ANTLR start "rule__ForBody__IndexesAssignment_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15202:1: rule__ForBody__IndexesAssignment_1 : ( ruleForValue ) ;
+ public final void rule__ForBody__IndexesAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15206:1: ( ( ruleForValue ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15207:1: ( ruleForValue )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15207:1: ( ruleForValue )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15208:1: ruleForValue
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_ruleForValue_in_rule__ForBody__IndexesAssignment_130825);
+ ruleForValue();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__IndexesAssignment_1"
+
+
+ // $ANTLR start "rule__ForBody__IndexesAssignment_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15217:1: rule__ForBody__IndexesAssignment_2_1 : ( ruleForValue ) ;
+ public final void rule__ForBody__IndexesAssignment_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15221:1: ( ( ruleForValue ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15222:1: ( ruleForValue )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15222:1: ( ruleForValue )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15223:1: ruleForValue
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0());
+ }
+ pushFollow(FOLLOW_ruleForValue_in_rule__ForBody__IndexesAssignment_2_130856);
+ ruleForValue();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__IndexesAssignment_2_1"
+
+
+ // $ANTLR start "rule__ForBody__SourceAssignment_3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15232:1: rule__ForBody__SourceAssignment_3 : ( ruleForSource ) ;
+ public final void rule__ForBody__SourceAssignment_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15236:1: ( ( ruleForSource ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15237:1: ( ruleForSource )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15237:1: ( ruleForSource )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15238:1: ruleForSource
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0());
+ }
+ pushFollow(FOLLOW_ruleForSource_in_rule__ForBody__SourceAssignment_330887);
+ ruleForSource();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForBody__SourceAssignment_3"
+
+
+ // $ANTLR start "rule__ForSource__SourceAssignment_1_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15247:1: rule__ForSource__SourceAssignment_1_0_1 : ( ruleExpression ) ;
+ public final void rule__ForSource__SourceAssignment_1_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15251:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15252:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15252:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15253:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ForSource__SourceAssignment_1_0_130918);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__SourceAssignment_1_0_1"
+
+
+ // $ANTLR start "rule__ForSource__WhenAssignment_1_0_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15262:1: rule__ForSource__WhenAssignment_1_0_2_1 : ( ruleExpression ) ;
+ public final void rule__ForSource__WhenAssignment_1_0_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15266:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15267:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15267:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15268:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ForSource__WhenAssignment_1_0_2_130949);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__WhenAssignment_1_0_2_1"
+
+
+ // $ANTLR start "rule__ForSource__SourceAssignment_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15277:1: rule__ForSource__SourceAssignment_1_1_1 : ( ruleExpression ) ;
+ public final void rule__ForSource__SourceAssignment_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15281:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15282:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15282:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15283:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ForSource__SourceAssignment_1_1_130980);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__SourceAssignment_1_1_1"
+
+
+ // $ANTLR start "rule__ForSource__WhenAssignment_1_1_2_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15292:1: rule__ForSource__WhenAssignment_1_1_2_0_1 : ( ruleExpression ) ;
+ public final void rule__ForSource__WhenAssignment_1_1_2_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15296:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15297:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15297:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15298:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ForSource__WhenAssignment_1_1_2_0_131011);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__WhenAssignment_1_1_2_0_1"
+
+
+ // $ANTLR start "rule__ForSource__ByAssignment_1_1_2_0_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15307:1: rule__ForSource__ByAssignment_1_1_2_0_2_1 : ( ruleExpression ) ;
+ public final void rule__ForSource__ByAssignment_1_1_2_0_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15311:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15312:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15312:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15313:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ForSource__ByAssignment_1_1_2_0_2_131042);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__ByAssignment_1_1_2_0_2_1"
+
+
+ // $ANTLR start "rule__ForSource__ByAssignment_1_1_2_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15322:1: rule__ForSource__ByAssignment_1_1_2_1_1 : ( ruleExpression ) ;
+ public final void rule__ForSource__ByAssignment_1_1_2_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15326:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15327:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15327:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15328:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ForSource__ByAssignment_1_1_2_1_131073);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__ByAssignment_1_1_2_1_1"
+
+
+ // $ANTLR start "rule__ForSource__WhenAssignment_1_1_2_1_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15337:1: rule__ForSource__WhenAssignment_1_1_2_1_2_1 : ( ruleExpression ) ;
+ public final void rule__ForSource__WhenAssignment_1_1_2_1_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15341:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15342:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15342:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15343:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__ForSource__WhenAssignment_1_1_2_1_2_131104);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ForSource__WhenAssignment_1_1_2_1_2_1"
+
+
+ // $ANTLR start "rule__Range__StartAssignment_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15352:1: rule__Range__StartAssignment_0_0_1 : ( ruleExpression ) ;
+ public final void rule__Range__StartAssignment_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15356:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15357:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15357:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15358:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Range__StartAssignment_0_0_131135);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__StartAssignment_0_0_1"
+
+
+ // $ANTLR start "rule__Range__EndAssignment_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15367:1: rule__Range__EndAssignment_1 : ( ruleExpression ) ;
+ public final void rule__Range__EndAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15371:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15372:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15372:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15373:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Range__EndAssignment_131166);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Range__EndAssignment_1"
+
+
+ // $ANTLR start "rule__Assignment__LeftAssignment_0_0_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15382:1: rule__Assignment__LeftAssignment_0_0_0_0 : ( ruleAssignable ) ;
+ public final void rule__Assignment__LeftAssignment_0_0_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15386:1: ( ( ruleAssignable ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15387:1: ( ruleAssignable )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15387:1: ( ruleAssignable )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15388:1: ruleAssignable
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0());
+ }
+ pushFollow(FOLLOW_ruleAssignable_in_rule__Assignment__LeftAssignment_0_0_0_031197);
+ ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__LeftAssignment_0_0_0_0"
+
+
+ // $ANTLR start "rule__Assignment__OperatorAssignment_0_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15397:1: rule__Assignment__OperatorAssignment_0_0_0_1 : ( ( rule__Assignment__OperatorAlternatives_0_0_0_1_0 ) ) ;
+ public final void rule__Assignment__OperatorAssignment_0_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15401:1: ( ( ( rule__Assignment__OperatorAlternatives_0_0_0_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15402:1: ( ( rule__Assignment__OperatorAlternatives_0_0_0_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15402:1: ( ( rule__Assignment__OperatorAlternatives_0_0_0_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15403:1: ( rule__Assignment__OperatorAlternatives_0_0_0_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getOperatorAlternatives_0_0_0_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15404:1: ( rule__Assignment__OperatorAlternatives_0_0_0_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15404:2: rule__Assignment__OperatorAlternatives_0_0_0_1_0
+ {
+ pushFollow(FOLLOW_rule__Assignment__OperatorAlternatives_0_0_0_1_0_in_rule__Assignment__OperatorAssignment_0_0_0_131228);
+ rule__Assignment__OperatorAlternatives_0_0_0_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getOperatorAlternatives_0_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__OperatorAssignment_0_0_0_1"
+
+
+ // $ANTLR start "rule__Assignment__RightAssignment_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15413:1: rule__Assignment__RightAssignment_0_1 : ( ruleAssigned ) ;
+ public final void rule__Assignment__RightAssignment_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15417:1: ( ( ruleAssigned ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15418:1: ( ruleAssigned )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15418:1: ( ruleAssigned )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15419:1: ruleAssigned
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleAssigned_in_rule__Assignment__RightAssignment_0_131261);
+ ruleAssigned();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Assignment__RightAssignment_0_1"
+
+
+ // $ANTLR start "rule__LogicOp__OperatorAssignment_1_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15428:1: rule__LogicOp__OperatorAssignment_1_0_0_1 : ( RULE_LOGIC ) ;
+ public final void rule__LogicOp__OperatorAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15432:1: ( ( RULE_LOGIC ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15433:1: ( RULE_LOGIC )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15433:1: ( RULE_LOGIC )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15434:1: RULE_LOGIC
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0());
+ }
+ match(input,RULE_LOGIC,FOLLOW_RULE_LOGIC_in_rule__LogicOp__OperatorAssignment_1_0_0_131292); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__OperatorAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__LogicOp__RightAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15443:1: rule__LogicOp__RightAssignment_1_1 : ( ruleCompareOp ) ;
+ public final void rule__LogicOp__RightAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15447:1: ( ( ruleCompareOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15448:1: ( ruleCompareOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15448:1: ( ruleCompareOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15449:1: ruleCompareOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleCompareOp_in_rule__LogicOp__RightAssignment_1_131323);
+ ruleCompareOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__LogicOp__RightAssignment_1_1"
+
+
+ // $ANTLR start "rule__CompareOp__OperatorAssignment_1_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15458:1: rule__CompareOp__OperatorAssignment_1_0_0_1 : ( RULE_COMPARE ) ;
+ public final void rule__CompareOp__OperatorAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15462:1: ( ( RULE_COMPARE ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15463:1: ( RULE_COMPARE )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15463:1: ( RULE_COMPARE )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15464:1: RULE_COMPARE
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0());
+ }
+ match(input,RULE_COMPARE,FOLLOW_RULE_COMPARE_in_rule__CompareOp__OperatorAssignment_1_0_0_131354); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__OperatorAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__CompareOp__RightAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15473:1: rule__CompareOp__RightAssignment_1_1 : ( ruleRelationOp ) ;
+ public final void rule__CompareOp__RightAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15477:1: ( ( ruleRelationOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15478:1: ( ruleRelationOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15478:1: ( ruleRelationOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15479:1: ruleRelationOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleRelationOp_in_rule__CompareOp__RightAssignment_1_131385);
+ ruleRelationOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CompareOp__RightAssignment_1_1"
+
+
+ // $ANTLR start "rule__RelationOp__OperatorAssignment_1_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15488:1: rule__RelationOp__OperatorAssignment_1_0_0_1 : ( RULE_RELATION ) ;
+ public final void rule__RelationOp__OperatorAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15492:1: ( ( RULE_RELATION ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15493:1: ( RULE_RELATION )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15493:1: ( RULE_RELATION )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15494:1: RULE_RELATION
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0());
+ }
+ match(input,RULE_RELATION,FOLLOW_RULE_RELATION_in_rule__RelationOp__OperatorAssignment_1_0_0_131416); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__OperatorAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__RelationOp__RightAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15503:1: rule__RelationOp__RightAssignment_1_1 : ( ruleShiftOp ) ;
+ public final void rule__RelationOp__RightAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15507:1: ( ( ruleShiftOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15508:1: ( ruleShiftOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15508:1: ( ruleShiftOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15509:1: ruleShiftOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleShiftOp_in_rule__RelationOp__RightAssignment_1_131447);
+ ruleShiftOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__RelationOp__RightAssignment_1_1"
+
+
+ // $ANTLR start "rule__ShiftOp__OperatorAssignment_1_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15518:1: rule__ShiftOp__OperatorAssignment_1_0_0_1 : ( RULE_SHIFT ) ;
+ public final void rule__ShiftOp__OperatorAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15522:1: ( ( RULE_SHIFT ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15523:1: ( RULE_SHIFT )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15523:1: ( RULE_SHIFT )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15524:1: RULE_SHIFT
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0());
+ }
+ match(input,RULE_SHIFT,FOLLOW_RULE_SHIFT_in_rule__ShiftOp__OperatorAssignment_1_0_0_131478); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__OperatorAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__ShiftOp__RightAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15533:1: rule__ShiftOp__RightAssignment_1_1 : ( ruleAdditiveOp ) ;
+ public final void rule__ShiftOp__RightAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15537:1: ( ( ruleAdditiveOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15538:1: ( ruleAdditiveOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15538:1: ( ruleAdditiveOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15539:1: ruleAdditiveOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleAdditiveOp_in_rule__ShiftOp__RightAssignment_1_131509);
+ ruleAdditiveOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ShiftOp__RightAssignment_1_1"
+
+
+ // $ANTLR start "rule__AdditiveOp__OperatorAssignment_1_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15548:1: rule__AdditiveOp__OperatorAssignment_1_0_0_1 : ( ( rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0 ) ) ;
+ public final void rule__AdditiveOp__OperatorAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15552:1: ( ( ( rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15553:1: ( ( rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15553:1: ( ( rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15554:1: ( rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getOperatorAlternatives_1_0_0_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15555:1: ( rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15555:2: rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0_in_rule__AdditiveOp__OperatorAssignment_1_0_0_131540);
+ rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getOperatorAlternatives_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__OperatorAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__AdditiveOp__RightAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15564:1: rule__AdditiveOp__RightAssignment_1_1 : ( ruleMathOp ) ;
+ public final void rule__AdditiveOp__RightAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15568:1: ( ( ruleMathOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15569:1: ( ruleMathOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15569:1: ( ruleMathOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15570:1: ruleMathOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleMathOp_in_rule__AdditiveOp__RightAssignment_1_131573);
+ ruleMathOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AdditiveOp__RightAssignment_1_1"
+
+
+ // $ANTLR start "rule__MathOp__OperatorAssignment_1_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15579:1: rule__MathOp__OperatorAssignment_1_0_0_1 : ( RULE_MATH ) ;
+ public final void rule__MathOp__OperatorAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15583:1: ( ( RULE_MATH ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15584:1: ( RULE_MATH )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15584:1: ( RULE_MATH )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15585:1: RULE_MATH
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0());
+ }
+ match(input,RULE_MATH,FOLLOW_RULE_MATH_in_rule__MathOp__OperatorAssignment_1_0_0_131604); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__OperatorAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__MathOp__RightAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15594:1: rule__MathOp__RightAssignment_1_1 : ( ruleUnaryOp ) ;
+ public final void rule__MathOp__RightAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15598:1: ( ( ruleUnaryOp ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15599:1: ( ruleUnaryOp )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15599:1: ( ruleUnaryOp )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15600:1: ruleUnaryOp
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleUnaryOp_in_rule__MathOp__RightAssignment_1_131635);
+ ruleUnaryOp();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__MathOp__RightAssignment_1_1"
+
+
+ // $ANTLR start "rule__Application__ArgsAssignment_0_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15609:1: rule__Application__ArgsAssignment_0_1_1_1 : ( ruleArgList ) ;
+ public final void rule__Application__ArgsAssignment_0_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15613:1: ( ( ruleArgList ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15614:1: ( ruleArgList )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15614:1: ( ruleArgList )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15615:1: ruleArgList
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleArgList_in_rule__Application__ArgsAssignment_0_1_1_131666);
+ ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__ArgsAssignment_0_1_1_1"
+
+
+ // $ANTLR start "rule__Application__ValueAssignment_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15624:1: rule__Application__ValueAssignment_1_0 : ( rulePrimaryExpression ) ;
+ public final void rule__Application__ValueAssignment_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15628:1: ( ( rulePrimaryExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15629:1: ( rulePrimaryExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15629:1: ( rulePrimaryExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15630:1: rulePrimaryExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0());
+ }
+ pushFollow(FOLLOW_rulePrimaryExpression_in_rule__Application__ValueAssignment_1_031697);
+ rulePrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__ValueAssignment_1_0"
+
+
+ // $ANTLR start "rule__Application__FeaturesAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15639:1: rule__Application__FeaturesAssignment_1_1 : ( ruleFeatureCall ) ;
+ public final void rule__Application__FeaturesAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15643:1: ( ( ruleFeatureCall ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15644:1: ( ruleFeatureCall )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15644:1: ( ruleFeatureCall )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15645:1: ruleFeatureCall
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleFeatureCall_in_rule__Application__FeaturesAssignment_1_131728);
+ ruleFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Application__FeaturesAssignment_1_1"
+
+
+ // $ANTLR start "rule__FunctionCall__ArgsAssignment_3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15654:1: rule__FunctionCall__ArgsAssignment_3 : ( ruleArgList ) ;
+ public final void rule__FunctionCall__ArgsAssignment_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15658:1: ( ( ruleArgList ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15659:1: ( ruleArgList )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15659:1: ( ruleArgList )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15660:1: ruleArgList
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0());
+ }
+ pushFollow(FOLLOW_ruleArgList_in_rule__FunctionCall__ArgsAssignment_331759);
+ ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__FunctionCall__ArgsAssignment_3"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__AccessorAssignment_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15669:1: rule__NamedPropertyAccess__AccessorAssignment_0_0 : ( ( rule__NamedPropertyAccess__AccessorAlternatives_0_0_0 ) ) ;
+ public final void rule__NamedPropertyAccess__AccessorAssignment_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15673:1: ( ( ( rule__NamedPropertyAccess__AccessorAlternatives_0_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15674:1: ( ( rule__NamedPropertyAccess__AccessorAlternatives_0_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15674:1: ( ( rule__NamedPropertyAccess__AccessorAlternatives_0_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15675:1: ( rule__NamedPropertyAccess__AccessorAlternatives_0_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorAlternatives_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15676:1: ( rule__NamedPropertyAccess__AccessorAlternatives_0_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15676:2: rule__NamedPropertyAccess__AccessorAlternatives_0_0_0
+ {
+ pushFollow(FOLLOW_rule__NamedPropertyAccess__AccessorAlternatives_0_0_0_in_rule__NamedPropertyAccess__AccessorAssignment_0_031790);
+ rule__NamedPropertyAccess__AccessorAlternatives_0_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorAlternatives_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__AccessorAssignment_0_0"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__NameAssignment_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15685:1: rule__NamedPropertyAccess__NameAssignment_0_1 : ( ruleId ) ;
+ public final void rule__NamedPropertyAccess__NameAssignment_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15689:1: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15690:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15690:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15691:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__NamedPropertyAccess__NameAssignment_0_131823);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__NameAssignment_0_1"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__AccessorAssignment_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15700:1: rule__NamedPropertyAccess__AccessorAssignment_1_0 : ( RULE_DOUBLE_COLON ) ;
+ public final void rule__NamedPropertyAccess__AccessorAssignment_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15704:1: ( ( RULE_DOUBLE_COLON ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15705:1: ( RULE_DOUBLE_COLON )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15705:1: ( RULE_DOUBLE_COLON )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15706:1: RULE_DOUBLE_COLON
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0());
+ }
+ match(input,RULE_DOUBLE_COLON,FOLLOW_RULE_DOUBLE_COLON_in_rule__NamedPropertyAccess__AccessorAssignment_1_031854); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__AccessorAssignment_1_0"
+
+
+ // $ANTLR start "rule__NamedPropertyAccess__NameAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15715:1: rule__NamedPropertyAccess__NameAssignment_1_1 : ( ruleId ) ;
+ public final void rule__NamedPropertyAccess__NameAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15719:1: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15720:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15720:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15721:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__NamedPropertyAccess__NameAssignment_1_131885);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__NamedPropertyAccess__NameAssignment_1_1"
+
+
+ // $ANTLR start "rule__IndexedPropertyAccess__IndexAssignment_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15730:1: rule__IndexedPropertyAccess__IndexAssignment_1 : ( ruleIndex ) ;
+ public final void rule__IndexedPropertyAccess__IndexAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15734:1: ( ( ruleIndex ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15735:1: ( ruleIndex )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15735:1: ( ruleIndex )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15736:1: ruleIndex
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_ruleIndex_in_rule__IndexedPropertyAccess__IndexAssignment_131916);
+ ruleIndex();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IndexedPropertyAccess__IndexAssignment_1"
+
+
+ // $ANTLR start "rule__Index__DotsAssignment_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15745:1: rule__Index__DotsAssignment_0_0 : ( ( rule__Index__DotsAlternatives_0_0_0 ) ) ;
+ public final void rule__Index__DotsAssignment_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15749:1: ( ( ( rule__Index__DotsAlternatives_0_0_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15750:1: ( ( rule__Index__DotsAlternatives_0_0_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15750:1: ( ( rule__Index__DotsAlternatives_0_0_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15751:1: ( rule__Index__DotsAlternatives_0_0_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getDotsAlternatives_0_0_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15752:1: ( rule__Index__DotsAlternatives_0_0_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15752:2: rule__Index__DotsAlternatives_0_0_0
+ {
+ pushFollow(FOLLOW_rule__Index__DotsAlternatives_0_0_0_in_rule__Index__DotsAssignment_0_031947);
+ rule__Index__DotsAlternatives_0_0_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getDotsAlternatives_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__DotsAssignment_0_0"
+
+
+ // $ANTLR start "rule__Index__EndAssignment_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15761:1: rule__Index__EndAssignment_0_1 : ( ruleExpression ) ;
+ public final void rule__Index__EndAssignment_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15765:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15766:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15766:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15767:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Index__EndAssignment_0_131980);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__EndAssignment_0_1"
+
+
+ // $ANTLR start "rule__Index__StartAssignment_1_0_0_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15776:1: rule__Index__StartAssignment_1_0_0_0 : ( ruleExpression ) ;
+ public final void rule__Index__StartAssignment_1_0_0_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15780:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15781:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15781:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15782:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Index__StartAssignment_1_0_0_032011);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__StartAssignment_1_0_0_0"
+
+
+ // $ANTLR start "rule__Index__DotsAssignment_1_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15791:1: rule__Index__DotsAssignment_1_0_0_1 : ( ( rule__Index__DotsAlternatives_1_0_0_1_0 ) ) ;
+ public final void rule__Index__DotsAssignment_1_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15795:1: ( ( ( rule__Index__DotsAlternatives_1_0_0_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15796:1: ( ( rule__Index__DotsAlternatives_1_0_0_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15796:1: ( ( rule__Index__DotsAlternatives_1_0_0_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15797:1: ( rule__Index__DotsAlternatives_1_0_0_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getDotsAlternatives_1_0_0_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15798:1: ( rule__Index__DotsAlternatives_1_0_0_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15798:2: rule__Index__DotsAlternatives_1_0_0_1_0
+ {
+ pushFollow(FOLLOW_rule__Index__DotsAlternatives_1_0_0_1_0_in_rule__Index__DotsAssignment_1_0_0_132042);
+ rule__Index__DotsAlternatives_1_0_0_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getDotsAlternatives_1_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__DotsAssignment_1_0_0_1"
+
+
+ // $ANTLR start "rule__Index__EndAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15807:1: rule__Index__EndAssignment_1_1 : ( ruleExpression ) ;
+ public final void rule__Index__EndAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15811:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15812:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15812:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15813:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Index__EndAssignment_1_132075);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__EndAssignment_1_1"
+
+
+ // $ANTLR start "rule__Index__ExpAssignment_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15822:1: rule__Index__ExpAssignment_2 : ( ruleExpression ) ;
+ public final void rule__Index__ExpAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15826:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15827:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15827:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15828:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Index__ExpAssignment_232106);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Index__ExpAssignment_2"
+
+
+ // $ANTLR start "rule__PrimaryExpression__LoopAssignment_9_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15837:1: rule__PrimaryExpression__LoopAssignment_9_1_1 : ( ruleForBody ) ;
+ public final void rule__PrimaryExpression__LoopAssignment_9_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15841:1: ( ( ruleForBody ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15842:1: ( ruleForBody )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15842:1: ( ruleForBody )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15843:1: ruleForBody
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleForBody_in_rule__PrimaryExpression__LoopAssignment_9_1_132137);
+ ruleForBody();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__LoopAssignment_9_1_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__BodyAssignment_9_1_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15852:1: rule__PrimaryExpression__BodyAssignment_9_1_2 : ( ruleBlock ) ;
+ public final void rule__PrimaryExpression__BodyAssignment_9_1_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15856:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15857:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15857:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15858:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_9_1_232168);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__BodyAssignment_9_1_2"
+
+
+ // $ANTLR start "rule__PrimaryExpression__LoopAssignment_10_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15867:1: rule__PrimaryExpression__LoopAssignment_10_1_1 : ( ruleExpression ) ;
+ public final void rule__PrimaryExpression__LoopAssignment_10_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15871:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15872:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15872:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15873:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__PrimaryExpression__LoopAssignment_10_1_132199);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__LoopAssignment_10_1_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__WhenAssignment_10_1_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15882:1: rule__PrimaryExpression__WhenAssignment_10_1_2_1 : ( ruleExpression ) ;
+ public final void rule__PrimaryExpression__WhenAssignment_10_1_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15886:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15887:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15887:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15888:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__PrimaryExpression__WhenAssignment_10_1_2_132230);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__WhenAssignment_10_1_2_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__BodyAssignment_10_1_3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15897:1: rule__PrimaryExpression__BodyAssignment_10_1_3 : ( ruleBlock ) ;
+ public final void rule__PrimaryExpression__BodyAssignment_10_1_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15901:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15902:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15902:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15903:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_10_1_332261);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__BodyAssignment_10_1_3"
+
+
+ // $ANTLR start "rule__PrimaryExpression__LoopAssignment_11_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15912:1: rule__PrimaryExpression__LoopAssignment_11_1_1 : ( ruleExpression ) ;
+ public final void rule__PrimaryExpression__LoopAssignment_11_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15916:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15917:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15917:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15918:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__PrimaryExpression__LoopAssignment_11_1_132292);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__LoopAssignment_11_1_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__WhenAssignment_11_1_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15927:1: rule__PrimaryExpression__WhenAssignment_11_1_2_1 : ( ruleExpression ) ;
+ public final void rule__PrimaryExpression__WhenAssignment_11_1_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15931:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15932:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15932:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15933:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__PrimaryExpression__WhenAssignment_11_1_2_132323);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__WhenAssignment_11_1_2_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__BodyAssignment_11_1_3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15942:1: rule__PrimaryExpression__BodyAssignment_11_1_3 : ( ruleBlock ) ;
+ public final void rule__PrimaryExpression__BodyAssignment_11_1_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15946:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15947:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15947:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15948:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_11_1_332354);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__BodyAssignment_11_1_3"
+
+
+ // $ANTLR start "rule__PrimaryExpression__BodyAssignment_12_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15957:1: rule__PrimaryExpression__BodyAssignment_12_1_1 : ( ruleBlock ) ;
+ public final void rule__PrimaryExpression__BodyAssignment_12_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15961:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15962:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15962:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15963:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_12_1_132385);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__BodyAssignment_12_1_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__BodyAssignment_13_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15972:1: rule__PrimaryExpression__BodyAssignment_13_1_1 : ( ruleBlock ) ;
+ public final void rule__PrimaryExpression__BodyAssignment_13_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15976:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15977:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15977:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15978:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_13_1_132416);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__BodyAssignment_13_1_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15987:1: rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1 : ( ruleId ) ;
+ public final void rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15991:1: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15992:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15992:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:15993:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_132447);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16002:1: rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2 : ( ruleBlock ) ;
+ public final void rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16006:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16007:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16007:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16008:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_232478);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2"
+
+
+ // $ANTLR start "rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16017:1: rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1 : ( ruleBlock ) ;
+ public final void rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16021:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16022:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16022:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16023:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_132509);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16032:1: rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1 : ( ruleBlock ) ;
+ public final void rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16036:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16037:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16037:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16038:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_132540);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__ExpAssignment_14_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16047:1: rule__PrimaryExpression__ExpAssignment_14_1_1 : ( ruleExpression ) ;
+ public final void rule__PrimaryExpression__ExpAssignment_14_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16051:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16052:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16052:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16053:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__PrimaryExpression__ExpAssignment_14_1_132571);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__ExpAssignment_14_1_1"
+
+
+ // $ANTLR start "rule__PrimaryExpression__CasesAssignment_14_1_3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16062:1: rule__PrimaryExpression__CasesAssignment_14_1_3 : ( ruleCase ) ;
+ public final void rule__PrimaryExpression__CasesAssignment_14_1_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16066:1: ( ( ruleCase ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16067:1: ( ruleCase )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16067:1: ( ruleCase )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16068:1: ruleCase
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0());
+ }
+ pushFollow(FOLLOW_ruleCase_in_rule__PrimaryExpression__CasesAssignment_14_1_332602);
+ ruleCase();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__CasesAssignment_14_1_3"
+
+
+ // $ANTLR start "rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16077:1: rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1 : ( ruleBlock ) ;
+ public final void rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16081:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16082:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16082:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16083:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__PrimaryExpression__ElseBlockAssignment_14_1_4_132633);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1"
+
+
+ // $ANTLR start "rule__Case__WhensAssignment_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16092:1: rule__Case__WhensAssignment_1 : ( ruleExpression ) ;
+ public final void rule__Case__WhensAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16096:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16097:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16097:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16098:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Case__WhensAssignment_132664);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__WhensAssignment_1"
+
+
+ // $ANTLR start "rule__Case__WhensAssignment_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16107:1: rule__Case__WhensAssignment_2_1 : ( ruleExpression ) ;
+ public final void rule__Case__WhensAssignment_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16111:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16112:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16112:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16113:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Case__WhensAssignment_2_132695);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__WhensAssignment_2_1"
+
+
+ // $ANTLR start "rule__Case__ThenAssignment_3"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16122:1: rule__Case__ThenAssignment_3 : ( ruleBlock ) ;
+ public final void rule__Case__ThenAssignment_3() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16126:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16127:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16127:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16128:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__Case__ThenAssignment_332726);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Case__ThenAssignment_3"
+
+
+ // $ANTLR start "rule__IfExp__BlocksAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16137:1: rule__IfExp__BlocksAssignment_0 : ( ruleCondBlock ) ;
+ public final void rule__IfExp__BlocksAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16141:1: ( ( ruleCondBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16142:1: ( ruleCondBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16142:1: ( ruleCondBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16143:1: ruleCondBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleCondBlock_in_rule__IfExp__BlocksAssignment_032757);
+ ruleCondBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__BlocksAssignment_0"
+
+
+ // $ANTLR start "rule__IfExp__BlocksAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16152:1: rule__IfExp__BlocksAssignment_1_1 : ( ruleCondBlock ) ;
+ public final void rule__IfExp__BlocksAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16156:1: ( ( ruleCondBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16157:1: ( ruleCondBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16157:1: ( ruleCondBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16158:1: ruleCondBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleCondBlock_in_rule__IfExp__BlocksAssignment_1_132788);
+ ruleCondBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__BlocksAssignment_1_1"
+
+
+ // $ANTLR start "rule__IfExp__DefaultBlockAssignment_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16167:1: rule__IfExp__DefaultBlockAssignment_2_1 : ( ruleBlock ) ;
+ public final void rule__IfExp__DefaultBlockAssignment_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16171:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16172:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16172:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16173:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__IfExp__DefaultBlockAssignment_2_132819);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IfExp__DefaultBlockAssignment_2_1"
+
+
+ // $ANTLR start "rule__CondBlock__OperatorAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16182:1: rule__CondBlock__OperatorAssignment_0 : ( RULE_IF ) ;
+ public final void rule__CondBlock__OperatorAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16186:1: ( ( RULE_IF ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16187:1: ( RULE_IF )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16187:1: ( RULE_IF )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16188:1: RULE_IF
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0());
+ }
+ match(input,RULE_IF,FOLLOW_RULE_IF_in_rule__CondBlock__OperatorAssignment_032850); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CondBlock__OperatorAssignment_0"
+
+
+ // $ANTLR start "rule__CondBlock__ConditionAssignment_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16197:1: rule__CondBlock__ConditionAssignment_1 : ( ruleExpression ) ;
+ public final void rule__CondBlock__ConditionAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16201:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16202:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16202:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16203:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__CondBlock__ConditionAssignment_132881);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CondBlock__ConditionAssignment_1"
+
+
+ // $ANTLR start "rule__CondBlock__ActionAssignment_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16212:1: rule__CondBlock__ActionAssignment_2 : ( ruleBlock ) ;
+ public final void rule__CondBlock__ActionAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16216:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16217:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16217:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16218:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__CondBlock__ActionAssignment_232912);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__CondBlock__ActionAssignment_2"
+
+
+ // $ANTLR start "rule__IdRef__ValAssignment"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16227:1: rule__IdRef__ValAssignment : ( ( RULE_IDENTIFIER ) ) ;
+ public final void rule__IdRef__ValAssignment() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16231:1: ( ( ( RULE_IDENTIFIER ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16232:1: ( ( RULE_IDENTIFIER ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16232:1: ( ( RULE_IDENTIFIER ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16233:1: ( RULE_IDENTIFIER )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdRefAccess().getValIdCrossReference_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16234:1: ( RULE_IDENTIFIER )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16235:1: RULE_IDENTIFIER
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdRefAccess().getValIdIDENTIFIERTerminalRuleCall_0_1());
+ }
+ match(input,RULE_IDENTIFIER,FOLLOW_RULE_IDENTIFIER_in_rule__IdRef__ValAssignment32947); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdRefAccess().getValIdIDENTIFIERTerminalRuleCall_0_1());
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdRefAccess().getValIdCrossReference_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__IdRef__ValAssignment"
+
+
+ // $ANTLR start "rule__Id__NameAssignment"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16246:1: rule__Id__NameAssignment : ( RULE_IDENTIFIER ) ;
+ public final void rule__Id__NameAssignment() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16250:1: ( ( RULE_IDENTIFIER ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16251:1: ( RULE_IDENTIFIER )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16251:1: ( RULE_IDENTIFIER )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16252:1: RULE_IDENTIFIER
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0());
+ }
+ match(input,RULE_IDENTIFIER,FOLLOW_RULE_IDENTIFIER_in_rule__Id__NameAssignment32982); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Id__NameAssignment"
+
+
+ // $ANTLR start "rule__Property__AccessorAssignment_0_0_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16261:1: rule__Property__AccessorAssignment_0_0_0_1 : ( ( rule__Property__AccessorAlternatives_0_0_0_1_0 ) ) ;
+ public final void rule__Property__AccessorAssignment_0_0_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16265:1: ( ( ( rule__Property__AccessorAlternatives_0_0_0_1_0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16266:1: ( ( rule__Property__AccessorAlternatives_0_0_0_1_0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16266:1: ( ( rule__Property__AccessorAlternatives_0_0_0_1_0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16267:1: ( rule__Property__AccessorAlternatives_0_0_0_1_0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getAccessorAlternatives_0_0_0_1_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16268:1: ( rule__Property__AccessorAlternatives_0_0_0_1_0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16268:2: rule__Property__AccessorAlternatives_0_0_0_1_0
+ {
+ pushFollow(FOLLOW_rule__Property__AccessorAlternatives_0_0_0_1_0_in_rule__Property__AccessorAssignment_0_0_0_133013);
+ rule__Property__AccessorAlternatives_0_0_0_1_0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getAccessorAlternatives_0_0_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__AccessorAssignment_0_0_0_1"
+
+
+ // $ANTLR start "rule__Property__PropAssignment_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16277:1: rule__Property__PropAssignment_0_1 : ( ruleId ) ;
+ public final void rule__Property__PropAssignment_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16281:1: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16282:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16282:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16283:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__Property__PropAssignment_0_133046);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__PropAssignment_0_1"
+
+
+ // $ANTLR start "rule__Property__IndexAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16292:1: rule__Property__IndexAssignment_1_1 : ( ruleIndex ) ;
+ public final void rule__Property__IndexAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16296:1: ( ( ruleIndex ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16297:1: ( ruleIndex )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16297:1: ( ruleIndex )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16298:1: ruleIndex
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleIndex_in_rule__Property__IndexAssignment_1_133077);
+ ruleIndex();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Property__IndexAssignment_1_1"
+
+
+ // $ANTLR start "rule__Variable__PropsAssignment_1_2_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16307:1: rule__Variable__PropsAssignment_1_2_1 : ( ruleId ) ;
+ public final void rule__Variable__PropsAssignment_1_2_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16311:1: ( ( ruleId ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16312:1: ( ruleId )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16312:1: ( ruleId )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16313:1: ruleId
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0());
+ }
+ pushFollow(FOLLOW_ruleId_in_rule__Variable__PropsAssignment_1_2_133108);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Variable__PropsAssignment_1_2_1"
+
+
+ // $ANTLR start "rule__AssignableArgList__ArgsAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16322:1: rule__AssignableArgList__ArgsAssignment_0 : ( ruleAssignableArg ) ;
+ public final void rule__AssignableArgList__ArgsAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16326:1: ( ( ruleAssignableArg ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16327:1: ( ruleAssignableArg )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16327:1: ( ruleAssignableArg )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16328:1: ruleAssignableArg
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleAssignableArg_in_rule__AssignableArgList__ArgsAssignment_033139);
+ ruleAssignableArg();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__ArgsAssignment_0"
+
+
+ // $ANTLR start "rule__AssignableArgList__ArgsAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16337:1: rule__AssignableArgList__ArgsAssignment_1_1 : ( ruleAssignableArg ) ;
+ public final void rule__AssignableArgList__ArgsAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16341:1: ( ( ruleAssignableArg ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16342:1: ( ruleAssignableArg )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16342:1: ( ruleAssignableArg )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16343:1: ruleAssignableArg
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleAssignableArg_in_rule__AssignableArgList__ArgsAssignment_1_133170);
+ ruleAssignableArg();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArgList__ArgsAssignment_1_1"
+
+
+ // $ANTLR start "rule__AssignableArg__ArgAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16352:1: rule__AssignableArg__ArgAssignment_0 : ( ruleAssignable ) ;
+ public final void rule__AssignableArg__ArgAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16356:1: ( ( ruleAssignable ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16357:1: ( ruleAssignable )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16357:1: ( ruleAssignable )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16358:1: ruleAssignable
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleAssignable_in_rule__AssignableArg__ArgAssignment_033201);
+ ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArg__ArgAssignment_0"
+
+
+ // $ANTLR start "rule__AssignableArg__SplatAssignment_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16367:1: rule__AssignableArg__SplatAssignment_1 : ( RULE_ELLIPSIS ) ;
+ public final void rule__AssignableArg__SplatAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16371:1: ( ( RULE_ELLIPSIS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16372:1: ( RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16372:1: ( RULE_ELLIPSIS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16373:1: RULE_ELLIPSIS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+ }
+ match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_rule__AssignableArg__SplatAssignment_133232); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__AssignableArg__SplatAssignment_1"
+
+
+ // $ANTLR start "rule__Arg__ExpAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16382:1: rule__Arg__ExpAssignment_0 : ( ruleExpression ) ;
+ public final void rule__Arg__ExpAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16386:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16387:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16387:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16388:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Arg__ExpAssignment_033263);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Arg__ExpAssignment_0"
+
+
+ // $ANTLR start "rule__Arg__SplatAssignment_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16397:1: rule__Arg__SplatAssignment_1 : ( RULE_ELLIPSIS ) ;
+ public final void rule__Arg__SplatAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16401:1: ( ( RULE_ELLIPSIS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16402:1: ( RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16402:1: ( RULE_ELLIPSIS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16403:1: RULE_ELLIPSIS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+ }
+ match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_rule__Arg__SplatAssignment_133294); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Arg__SplatAssignment_1"
+
+
+ // $ANTLR start "rule__ArgLine__HeadAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16412:1: rule__ArgLine__HeadAssignment_0 : ( ruleArg ) ;
+ public final void rule__ArgLine__HeadAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16416:1: ( ( ruleArg ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16417:1: ( ruleArg )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16417:1: ( ruleArg )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16418:1: ruleArg
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleArg_in_rule__ArgLine__HeadAssignment_033325);
+ ruleArg();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__HeadAssignment_0"
+
+
+ // $ANTLR start "rule__ArgLine__TailAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16427:1: rule__ArgLine__TailAssignment_1_1 : ( ruleArg ) ;
+ public final void rule__ArgLine__TailAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16431:1: ( ( ruleArg ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16432:1: ( ruleArg )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16432:1: ( ruleArg )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16433:1: ruleArg
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleArg_in_rule__ArgLine__TailAssignment_1_133356);
+ ruleArg();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgLine__TailAssignment_1_1"
+
+
+ // $ANTLR start "rule__ExplicitArgList__LinesAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16442:1: rule__ExplicitArgList__LinesAssignment_0 : ( ruleArgLine ) ;
+ public final void rule__ExplicitArgList__LinesAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16446:1: ( ( ruleArgLine ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16447:1: ( ruleArgLine )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16447:1: ( ruleArgLine )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16448:1: ruleArgLine
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_rule__ExplicitArgList__LinesAssignment_033387);
+ ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__LinesAssignment_0"
+
+
+ // $ANTLR start "rule__ExplicitArgList__LinesAssignment_1_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16457:1: rule__ExplicitArgList__LinesAssignment_1_0_1 : ( ruleArgLine ) ;
+ public final void rule__ExplicitArgList__LinesAssignment_1_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16461:1: ( ( ruleArgLine ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16462:1: ( ruleArgLine )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16462:1: ( ruleArgLine )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16463:1: ruleArgLine
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_rule__ExplicitArgList__LinesAssignment_1_0_133418);
+ ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__LinesAssignment_1_0_1"
+
+
+ // $ANTLR start "rule__ExplicitArgList__LinesAssignment_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16472:1: rule__ExplicitArgList__LinesAssignment_1_1_1 : ( ruleArgLine ) ;
+ public final void rule__ExplicitArgList__LinesAssignment_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16476:1: ( ( ruleArgLine ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16477:1: ( ruleArgLine )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16477:1: ( ruleArgLine )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16478:1: ruleArgLine
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_rule__ExplicitArgList__LinesAssignment_1_1_133449);
+ ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitArgList__LinesAssignment_1_1_1"
+
+
+ // $ANTLR start "rule__ArgList__DummyAssignment_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16487:1: rule__ArgList__DummyAssignment_1_0 : ( ruleExplicitArgList ) ;
+ public final void rule__ArgList__DummyAssignment_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16491:1: ( ( ruleExplicitArgList ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16492:1: ( ruleExplicitArgList )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16492:1: ( ruleExplicitArgList )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16493:1: ruleExplicitArgList
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0());
+ }
+ pushFollow(FOLLOW_ruleExplicitArgList_in_rule__ArgList__DummyAssignment_1_033480);
+ ruleExplicitArgList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__DummyAssignment_1_0"
+
+
+ // $ANTLR start "rule__ArgList__DummyAssignment_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16502:1: rule__ArgList__DummyAssignment_1_1_1 : ( ruleExplicitArgList ) ;
+ public final void rule__ArgList__DummyAssignment_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16506:1: ( ( ruleExplicitArgList ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16507:1: ( ruleExplicitArgList )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16507:1: ( ruleExplicitArgList )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16508:1: ruleExplicitArgList
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExplicitArgList_in_rule__ArgList__DummyAssignment_1_1_133511);
+ ruleExplicitArgList();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ArgList__DummyAssignment_1_1_1"
+
+
+ // $ANTLR start "rule__DictItems__DummyAssignment_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16517:1: rule__DictItems__DummyAssignment_1_0 : ( ruleExplicitDictItems ) ;
+ public final void rule__DictItems__DummyAssignment_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16521:1: ( ( ruleExplicitDictItems ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16522:1: ( ruleExplicitDictItems )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16522:1: ( ruleExplicitDictItems )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16523:1: ruleExplicitDictItems
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0());
+ }
+ pushFollow(FOLLOW_ruleExplicitDictItems_in_rule__DictItems__DummyAssignment_1_033542);
+ ruleExplicitDictItems();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__DummyAssignment_1_0"
+
+
+ // $ANTLR start "rule__DictItems__DummyAssignment_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16532:1: rule__DictItems__DummyAssignment_1_1_1 : ( ruleExplicitDictItems ) ;
+ public final void rule__DictItems__DummyAssignment_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16536:1: ( ( ruleExplicitDictItems ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16537:1: ( ruleExplicitDictItems )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16537:1: ( ruleExplicitDictItems )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16538:1: ruleExplicitDictItems
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExplicitDictItems_in_rule__DictItems__DummyAssignment_1_1_133573);
+ ruleExplicitDictItems();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItems__DummyAssignment_1_1_1"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__LinesAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16547:1: rule__ExplicitDictItems__LinesAssignment_0 : ( ruleDictLine ) ;
+ public final void rule__ExplicitDictItems__LinesAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16551:1: ( ( ruleDictLine ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16552:1: ( ruleDictLine )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16552:1: ( ruleDictLine )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16553:1: ruleDictLine
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_rule__ExplicitDictItems__LinesAssignment_033604);
+ ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__LinesAssignment_0"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__LinesAssignment_1_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16562:1: rule__ExplicitDictItems__LinesAssignment_1_0_1 : ( ruleDictLine ) ;
+ public final void rule__ExplicitDictItems__LinesAssignment_1_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16566:1: ( ( ruleDictLine ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16567:1: ( ruleDictLine )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16567:1: ( ruleDictLine )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16568:1: ruleDictLine
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_rule__ExplicitDictItems__LinesAssignment_1_0_133635);
+ ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__LinesAssignment_1_0_1"
+
+
+ // $ANTLR start "rule__ExplicitDictItems__LinesAssignment_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16577:1: rule__ExplicitDictItems__LinesAssignment_1_1_1 : ( ruleDictLine ) ;
+ public final void rule__ExplicitDictItems__LinesAssignment_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16581:1: ( ( ruleDictLine ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16582:1: ( ruleDictLine )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16582:1: ( ruleDictLine )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16583:1: ruleDictLine
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_rule__ExplicitDictItems__LinesAssignment_1_1_133666);
+ ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__ExplicitDictItems__LinesAssignment_1_1_1"
+
+
+ // $ANTLR start "rule__DictLine__HeadAssignment_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16592:1: rule__DictLine__HeadAssignment_0 : ( ruleDictItem ) ;
+ public final void rule__DictLine__HeadAssignment_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16596:1: ( ( ruleDictItem ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16597:1: ( ruleDictItem )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16597:1: ( ruleDictItem )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16598:1: ruleDictItem
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0());
+ }
+ pushFollow(FOLLOW_ruleDictItem_in_rule__DictLine__HeadAssignment_033697);
+ ruleDictItem();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__HeadAssignment_0"
+
+
+ // $ANTLR start "rule__DictLine__TailAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16607:1: rule__DictLine__TailAssignment_1_1 : ( ruleDictItem ) ;
+ public final void rule__DictLine__TailAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16611:1: ( ( ruleDictItem ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16612:1: ( ruleDictItem )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16612:1: ( ruleDictItem )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16613:1: ruleDictItem
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleDictItem_in_rule__DictLine__TailAssignment_1_133728);
+ ruleDictItem();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictLine__TailAssignment_1_1"
+
+
+ // $ANTLR start "rule__DictItem__KeyAssignment_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16622:1: rule__DictItem__KeyAssignment_1 : ( ruleDictKey ) ;
+ public final void rule__DictItem__KeyAssignment_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16626:1: ( ( ruleDictKey ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16627:1: ( ruleDictKey )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16627:1: ( ruleDictKey )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16628:1: ruleDictKey
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0());
+ }
+ pushFollow(FOLLOW_ruleDictKey_in_rule__DictItem__KeyAssignment_133759);
+ ruleDictKey();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__KeyAssignment_1"
+
+
+ // $ANTLR start "rule__DictItem__ValueAssignment_2_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16637:1: rule__DictItem__ValueAssignment_2_1_0 : ( ruleExpression ) ;
+ public final void rule__DictItem__ValueAssignment_2_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16641:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16642:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16642:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16643:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__DictItem__ValueAssignment_2_1_033790);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__ValueAssignment_2_1_0"
+
+
+ // $ANTLR start "rule__DictItem__ValueAssignment_2_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16652:1: rule__DictItem__ValueAssignment_2_1_1_1 : ( ruleExpression ) ;
+ public final void rule__DictItem__ValueAssignment_2_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16656:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16657:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16657:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16658:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__DictItem__ValueAssignment_2_1_1_133821);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__DictItem__ValueAssignment_2_1_1_1"
+
+
+ // $ANTLR start "rule__Lambda__ParamsAssignment_0_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16667:1: rule__Lambda__ParamsAssignment_0_1_0 : ( ruleParam ) ;
+ public final void rule__Lambda__ParamsAssignment_0_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16671:1: ( ( ruleParam ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16672:1: ( ruleParam )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16672:1: ( ruleParam )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16673:1: ruleParam
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0());
+ }
+ pushFollow(FOLLOW_ruleParam_in_rule__Lambda__ParamsAssignment_0_1_033852);
+ ruleParam();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__ParamsAssignment_0_1_0"
+
+
+ // $ANTLR start "rule__Lambda__ParamsAssignment_0_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16682:1: rule__Lambda__ParamsAssignment_0_1_1_1 : ( ruleParam ) ;
+ public final void rule__Lambda__ParamsAssignment_0_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16686:1: ( ( ruleParam ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16687:1: ( ruleParam )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16687:1: ( ruleParam )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16688:1: ruleParam
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleParam_in_rule__Lambda__ParamsAssignment_0_1_1_133883);
+ ruleParam();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__ParamsAssignment_0_1_1_1"
+
+
+ // $ANTLR start "rule__Lambda__BodyAssignment_2"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16697:1: rule__Lambda__BodyAssignment_2 : ( ruleBlock ) ;
+ public final void rule__Lambda__BodyAssignment_2() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16701:1: ( ( ruleBlock ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16702:1: ( ruleBlock )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16702:1: ( ruleBlock )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16703:1: ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rule__Lambda__BodyAssignment_233914);
+ ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Lambda__BodyAssignment_2"
+
+
+ // $ANTLR start "rule__Param__SplatAssignment_1_0"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16712:1: rule__Param__SplatAssignment_1_0 : ( RULE_ELLIPSIS ) ;
+ public final void rule__Param__SplatAssignment_1_0() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16716:1: ( ( RULE_ELLIPSIS ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16717:1: ( RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16717:1: ( RULE_ELLIPSIS )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16718:1: RULE_ELLIPSIS
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0());
+ }
+ match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_rule__Param__SplatAssignment_1_033945); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__SplatAssignment_1_0"
+
+
+ // $ANTLR start "rule__Param__DefaultValueAssignment_1_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16727:1: rule__Param__DefaultValueAssignment_1_1_1 : ( ruleExpression ) ;
+ public final void rule__Param__DefaultValueAssignment_1_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16731:1: ( ( ruleExpression ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16732:1: ( ruleExpression )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16732:1: ( ruleExpression )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16733:1: ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rule__Param__DefaultValueAssignment_1_1_133976);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Param__DefaultValueAssignment_1_1_1"
+
+
+ // $ANTLR start "rule__Parenthetical__ContentAssignment_0_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16742:1: rule__Parenthetical__ContentAssignment_0_1 : ( ruleBody ) ;
+ public final void rule__Parenthetical__ContentAssignment_0_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16746:1: ( ( ruleBody ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16747:1: ( ruleBody )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16747:1: ( ruleBody )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16748:1: ruleBody
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0());
+ }
+ pushFollow(FOLLOW_ruleBody_in_rule__Parenthetical__ContentAssignment_0_134007);
+ ruleBody();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__ContentAssignment_0_1"
+
+
+ // $ANTLR start "rule__Parenthetical__ContentAssignment_1_1"
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16757:1: rule__Parenthetical__ContentAssignment_1_1 : ( ruleBody ) ;
+ public final void rule__Parenthetical__ContentAssignment_1_1() throws RecognitionException {
+
+ int stackSize = keepStackSize();
+
+ try {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16761:1: ( ( ruleBody ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16762:1: ( ruleBody )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16762:1: ( ruleBody )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:16763:1: ruleBody
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0());
+ }
+ pushFollow(FOLLOW_ruleBody_in_rule__Parenthetical__ContentAssignment_1_134038);
+ ruleBody();
+
+ state._fsp--;
+ if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ after(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0());
+ }
+
+ }
+
+
+ }
+
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ }
+ finally {
+
+ restoreStackSize(stackSize);
+
+ }
+ return ;
+ }
+ // $ANTLR end "rule__Parenthetical__ContentAssignment_1_1"
+
+ // $ANTLR start synpred20_InternalCakefile
+ public final void synpred20_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2257:1: ( ( ( rule__Assignment__Group_0__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2257:1: ( ( rule__Assignment__Group_0__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2257:1: ( ( rule__Assignment__Group_0__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2258:1: ( rule__Assignment__Group_0__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getAssignmentAccess().getGroup_0());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2259:1: ( rule__Assignment__Group_0__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2259:2: rule__Assignment__Group_0__0
+ {
+ pushFollow(FOLLOW_rule__Assignment__Group_0__0_in_synpred20_InternalCakefile4832);
+ rule__Assignment__Group_0__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred20_InternalCakefile
+
+ // $ANTLR start synpred36_InternalCakefile
+ public final void synpred36_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2545:6: ( ( ( rule__Index__Group_1__0 ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2545:6: ( ( rule__Index__Group_1__0 ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2545:6: ( ( rule__Index__Group_1__0 ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2546:1: ( rule__Index__Group_1__0 )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getIndexAccess().getGroup_1());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2547:1: ( rule__Index__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2547:2: rule__Index__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__Index__Group_1__0_in_synpred36_InternalCakefile5498);
+ rule__Index__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred36_InternalCakefile
+
+ // $ANTLR start synpred42_InternalCakefile
+ public final void synpred42_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2629:6: ( ( ( ruleRange ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2629:6: ( ( ruleRange ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2629:6: ( ( ruleRange ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2630:1: ( ruleRange )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2631:1: ( ruleRange )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2631:3: ruleRange
+ {
+ pushFollow(FOLLOW_ruleRange_in_synpred42_InternalCakefile5699);
+ ruleRange();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred42_InternalCakefile
+
+ // $ANTLR start synpred43_InternalCakefile
+ public final void synpred43_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2635:6: ( ( ( ruleArray ) ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2635:6: ( ( ruleArray ) )
+ {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2635:6: ( ( ruleArray ) )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2636:1: ( ruleArray )
+ {
+ if ( state.backtracking==0 ) {
+ before(grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4());
+ }
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2637:1: ( ruleArray )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:2637:3: ruleArray
+ {
+ pushFollow(FOLLOW_ruleArray_in_synpred43_InternalCakefile5718);
+ ruleArray();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred43_InternalCakefile
+
+ // $ANTLR start synpred89_InternalCakefile
+ public final void synpred89_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4910:2: ( rule__Postfix__Alternatives_1 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:4910:2: rule__Postfix__Alternatives_1
+ {
+ pushFollow(FOLLOW_rule__Postfix__Alternatives_1_in_synpred89_InternalCakefile10440);
+ rule__Postfix__Alternatives_1();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred89_InternalCakefile
+
+ // $ANTLR start synpred90_InternalCakefile
+ public final void synpred90_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5219:2: ( rule__Postfix__Group_1_2_3__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5219:2: rule__Postfix__Group_1_2_3__0
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_2_3__0_in_synpred90_InternalCakefile11054);
+ rule__Postfix__Group_1_2_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred90_InternalCakefile
+
+ // $ANTLR start synpred91_InternalCakefile
+ public final void synpred91_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5405:2: ( rule__Postfix__Group_1_3_3__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5405:2: rule__Postfix__Group_1_3_3__0
+ {
+ pushFollow(FOLLOW_rule__Postfix__Group_1_3_3__0_in_synpred91_InternalCakefile11424);
+ rule__Postfix__Group_1_3_3__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred91_InternalCakefile
+
+ // $ANTLR start synpred94_InternalCakefile
+ public final void synpred94_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5807:2: ( rule__ForSource__Group_1_0_2__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5807:2: rule__ForSource__Group_1_0_2__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_0_2__0_in_synpred94_InternalCakefile12223);
+ rule__ForSource__Group_1_0_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred94_InternalCakefile
+
+ // $ANTLR start synpred95_InternalCakefile
+ public final void synpred95_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5960:2: ( rule__ForSource__Alternatives_1_1_2 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:5960:2: rule__ForSource__Alternatives_1_1_2
+ {
+ pushFollow(FOLLOW_rule__ForSource__Alternatives_1_1_2_in_synpred95_InternalCakefile12530);
+ rule__ForSource__Alternatives_1_1_2();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred95_InternalCakefile
+
+ // $ANTLR start synpred96_InternalCakefile
+ public final void synpred96_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6052:2: ( rule__ForSource__Group_1_1_2_0_2__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6052:2: rule__ForSource__Group_1_1_2_0_2__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_0_2__0_in_synpred96_InternalCakefile12715);
+ rule__ForSource__Group_1_1_2_0_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred96_InternalCakefile
+
+ // $ANTLR start synpred97_InternalCakefile
+ public final void synpred97_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6205:2: ( rule__ForSource__Group_1_1_2_1_2__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6205:2: rule__ForSource__Group_1_1_2_1_2__0
+ {
+ pushFollow(FOLLOW_rule__ForSource__Group_1_1_2_1_2__0_in_synpred97_InternalCakefile13022);
+ rule__ForSource__Group_1_1_2_1_2__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred97_InternalCakefile
+
+ // $ANTLR start synpred98_InternalCakefile
+ public final void synpred98_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6787:2: ( rule__LogicOp__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:6787:2: rule__LogicOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__LogicOp__Group_1__0_in_synpred98_InternalCakefile14171);
+ rule__LogicOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred98_InternalCakefile
+
+ // $ANTLR start synpred99_InternalCakefile
+ public final void synpred99_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7002:2: ( rule__CompareOp__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7002:2: rule__CompareOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__CompareOp__Group_1__0_in_synpred99_InternalCakefile14594);
+ rule__CompareOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred99_InternalCakefile
+
+ // $ANTLR start synpred100_InternalCakefile
+ public final void synpred100_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7217:2: ( rule__RelationOp__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7217:2: rule__RelationOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__RelationOp__Group_1__0_in_synpred100_InternalCakefile15017);
+ rule__RelationOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred100_InternalCakefile
+
+ // $ANTLR start synpred101_InternalCakefile
+ public final void synpred101_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7432:2: ( rule__ShiftOp__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7432:2: rule__ShiftOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__ShiftOp__Group_1__0_in_synpred101_InternalCakefile15440);
+ rule__ShiftOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred101_InternalCakefile
+
+ // $ANTLR start synpred102_InternalCakefile
+ public final void synpred102_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7647:2: ( rule__AdditiveOp__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7647:2: rule__AdditiveOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__AdditiveOp__Group_1__0_in_synpred102_InternalCakefile15863);
+ rule__AdditiveOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred102_InternalCakefile
+
+ // $ANTLR start synpred103_InternalCakefile
+ public final void synpred103_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7862:2: ( rule__MathOp__Group_1__0 )
+ // ../csep.example.cake.ui/src-gen/csep/example/cake/ui/contentassist/antlr/internal/InternalCakefile.g:7862:2: rule__MathOp__Group_1__0
+ {
+ pushFollow(FOLLOW_rule__MathOp__Group_1__0_in_synpred103_InternalCakefile16286);
+ rule__MathOp__Group_1__0();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred103_InternalCakefile
+
+ // Delegated rules
+
+ public final boolean synpred99_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred99_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred36_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred36_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred96_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred96_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred20_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred20_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred94_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred94_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred95_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred95_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred101_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred101_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred103_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred103_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred97_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred97_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred91_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred91_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred102_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred102_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred100_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred100_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred42_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred42_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred90_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred90_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred89_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred89_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred98_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred98_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred43_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred43_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+
+
+ protected DFA13 dfa13 = new DFA13(this);
+ protected DFA25 dfa25 = new DFA25(this);
+ protected DFA28 dfa28 = new DFA28(this);
+ static final String DFA13_eotS =
+ "\35\uffff";
+ static final String DFA13_eofS =
+ "\35\uffff";
+ static final String DFA13_minS =
+ "\1\10\5\0\27\uffff";
+ static final String DFA13_maxS =
+ "\1\112\5\0\27\uffff";
+ static final String DFA13_acceptS =
+ "\6\uffff\1\2\25\uffff\1\1";
+ static final String DFA13_specialS =
+ "\1\uffff\1\0\1\1\1\2\1\3\1\4\27\uffff}>";
+ static final String[] DFA13_transitionS = {
+ "\5\6\3\uffff\1\2\2\6\5\uffff\1\6\6\uffff\2\6\1\uffff\1\6\5\uffff"+
+ "\1\5\3\uffff\1\6\3\uffff\1\3\2\6\2\uffff\1\6\2\uffff\1\4\2\uffff"+
+ "\5\6\1\uffff\1\6\7\uffff\1\6\1\1",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS);
+ static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS);
+ static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS);
+ static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS);
+ static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS);
+ static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS);
+ static final short[][] DFA13_transition;
+
+ static {
+ int numStates = DFA13_transitionS.length;
+ DFA13_transition = new short[numStates][];
+ for (int i=0; i=0 ) return s;
+ break;
+ case 1 :
+ int LA13_2 = input.LA(1);
+
+
+ int index13_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred20_InternalCakefile()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index13_2);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA13_3 = input.LA(1);
+
+
+ int index13_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred20_InternalCakefile()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index13_3);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA13_4 = input.LA(1);
+
+
+ int index13_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred20_InternalCakefile()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index13_4);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA13_5 = input.LA(1);
+
+
+ int index13_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred20_InternalCakefile()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index13_5);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 13, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA25_eotS =
+ "\40\uffff";
+ static final String DFA25_eofS =
+ "\40\uffff";
+ static final String DFA25_minS =
+ "\1\4\2\uffff\33\0\2\uffff";
+ static final String DFA25_maxS =
+ "\1\112\2\uffff\33\0\2\uffff";
+ static final String DFA25_acceptS =
+ "\1\uffff\1\1\34\uffff\1\2\1\3";
+ static final String DFA25_specialS =
+ "\3\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
+ "\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31"+
+ "\1\32\2\uffff}>";
+ static final String[] DFA25_transitionS = {
+ "\2\1\2\uffff\1\11\1\12\1\10\1\13\1\14\3\uffff\1\4\1\26\1\27"+
+ "\5\uffff\1\25\6\uffff\1\30\1\31\1\uffff\1\32\5\uffff\1\7\3\uffff"+
+ "\1\15\3\uffff\1\5\1\33\1\34\2\uffff\1\35\2\uffff\1\6\2\uffff"+
+ "\1\20\1\21\1\22\1\23\1\24\1\uffff\1\17\7\uffff\1\16\1\3",
+ "",
+ "",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ ""
+ };
+
+ static final short[] DFA25_eot = DFA.unpackEncodedString(DFA25_eotS);
+ static final short[] DFA25_eof = DFA.unpackEncodedString(DFA25_eofS);
+ static final char[] DFA25_min = DFA.unpackEncodedStringToUnsignedChars(DFA25_minS);
+ static final char[] DFA25_max = DFA.unpackEncodedStringToUnsignedChars(DFA25_maxS);
+ static final short[] DFA25_accept = DFA.unpackEncodedString(DFA25_acceptS);
+ static final short[] DFA25_special = DFA.unpackEncodedString(DFA25_specialS);
+ static final short[][] DFA25_transition;
+
+ static {
+ int numStates = DFA25_transitionS.length;
+ DFA25_transition = new short[numStates][];
+ for (int i=0; i=0 ) return s;
+ break;
+ case 1 :
+ int LA25_4 = input.LA(1);
+
+
+ int index25_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_4);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA25_5 = input.LA(1);
+
+
+ int index25_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_5);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA25_6 = input.LA(1);
+
+
+ int index25_6 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_6);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA25_7 = input.LA(1);
+
+
+ int index25_7 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_7);
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA25_8 = input.LA(1);
+
+
+ int index25_8 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_8);
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA25_9 = input.LA(1);
+
+
+ int index25_9 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_9);
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA25_10 = input.LA(1);
+
+
+ int index25_10 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_10);
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA25_11 = input.LA(1);
+
+
+ int index25_11 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_11);
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA25_12 = input.LA(1);
+
+
+ int index25_12 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_12);
+ if ( s>=0 ) return s;
+ break;
+ case 10 :
+ int LA25_13 = input.LA(1);
+
+
+ int index25_13 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_13);
+ if ( s>=0 ) return s;
+ break;
+ case 11 :
+ int LA25_14 = input.LA(1);
+
+
+ int index25_14 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_14);
+ if ( s>=0 ) return s;
+ break;
+ case 12 :
+ int LA25_15 = input.LA(1);
+
+
+ int index25_15 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_15);
+ if ( s>=0 ) return s;
+ break;
+ case 13 :
+ int LA25_16 = input.LA(1);
+
+
+ int index25_16 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_16);
+ if ( s>=0 ) return s;
+ break;
+ case 14 :
+ int LA25_17 = input.LA(1);
+
+
+ int index25_17 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_17);
+ if ( s>=0 ) return s;
+ break;
+ case 15 :
+ int LA25_18 = input.LA(1);
+
+
+ int index25_18 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_18);
+ if ( s>=0 ) return s;
+ break;
+ case 16 :
+ int LA25_19 = input.LA(1);
+
+
+ int index25_19 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_19);
+ if ( s>=0 ) return s;
+ break;
+ case 17 :
+ int LA25_20 = input.LA(1);
+
+
+ int index25_20 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_20);
+ if ( s>=0 ) return s;
+ break;
+ case 18 :
+ int LA25_21 = input.LA(1);
+
+
+ int index25_21 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_21);
+ if ( s>=0 ) return s;
+ break;
+ case 19 :
+ int LA25_22 = input.LA(1);
+
+
+ int index25_22 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_22);
+ if ( s>=0 ) return s;
+ break;
+ case 20 :
+ int LA25_23 = input.LA(1);
+
+
+ int index25_23 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_23);
+ if ( s>=0 ) return s;
+ break;
+ case 21 :
+ int LA25_24 = input.LA(1);
+
+
+ int index25_24 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_24);
+ if ( s>=0 ) return s;
+ break;
+ case 22 :
+ int LA25_25 = input.LA(1);
+
+
+ int index25_25 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_25);
+ if ( s>=0 ) return s;
+ break;
+ case 23 :
+ int LA25_26 = input.LA(1);
+
+
+ int index25_26 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_26);
+ if ( s>=0 ) return s;
+ break;
+ case 24 :
+ int LA25_27 = input.LA(1);
+
+
+ int index25_27 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_27);
+ if ( s>=0 ) return s;
+ break;
+ case 25 :
+ int LA25_28 = input.LA(1);
+
+
+ int index25_28 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_28);
+ if ( s>=0 ) return s;
+ break;
+ case 26 :
+ int LA25_29 = input.LA(1);
+
+
+ int index25_29 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred36_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index25_29);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 25, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA28_eotS =
+ "\30\uffff";
+ static final String DFA28_eofS =
+ "\30\uffff";
+ static final String DFA28_minS =
+ "\1\20\7\uffff\1\0\17\uffff";
+ static final String DFA28_maxS =
+ "\1\112\7\uffff\1\0\17\uffff";
+ static final String DFA28_acceptS =
+ "\1\uffff\1\1\1\2\1\3\5\uffff\1\6\1\7\2\uffff\1\10\1\11\1\12\1\13"+
+ "\1\14\1\15\1\16\1\17\1\20\1\4\1\5";
+ static final String DFA28_specialS =
+ "\10\uffff\1\0\17\uffff}>";
+ static final String[] DFA28_transitionS = {
+ "\1\15\2\12\5\uffff\1\12\6\uffff\1\17\1\20\1\uffff\1\21\5\uffff"+
+ "\1\10\7\uffff\1\16\1\22\1\23\2\uffff\1\24\2\uffff\1\11\2\uffff"+
+ "\5\3\1\uffff\1\2\7\uffff\1\1\1\25",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA28_eot = DFA.unpackEncodedString(DFA28_eotS);
+ static final short[] DFA28_eof = DFA.unpackEncodedString(DFA28_eofS);
+ static final char[] DFA28_min = DFA.unpackEncodedStringToUnsignedChars(DFA28_minS);
+ static final char[] DFA28_max = DFA.unpackEncodedStringToUnsignedChars(DFA28_maxS);
+ static final short[] DFA28_accept = DFA.unpackEncodedString(DFA28_acceptS);
+ static final short[] DFA28_special = DFA.unpackEncodedString(DFA28_specialS);
+ static final short[][] DFA28_transition;
+
+ static {
+ int numStates = DFA28_transitionS.length;
+ DFA28_transition = new short[numStates][];
+ for (int i=0; i=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 28, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+ public static final BitSet FOLLOW_ruleCakefile_in_entryRuleCakefile67 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCakefile74 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Cakefile__TasksAssignment_in_ruleCakefile100 = new BitSet(new long[]{0x0000000000080002L});
+ public static final BitSet FOLLOW_ruleTaskDeclaration_in_entryRuleTaskDeclaration128 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleTaskDeclaration135 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__0_in_ruleTaskDeclaration161 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBody_in_entryRuleBody190 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleBody197 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Body__Group__0_in_ruleBody223 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLine_in_entryRuleLine250 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLine257 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Line__Alternatives_in_ruleLine283 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStmt_in_entryRuleStmt310 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleStmt317 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Stmt__Alternatives_in_ruleStmt343 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleComment_in_entryRuleComment370 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleComment377 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Comment__CommentAssignment_in_ruleComment403 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRequireStmt_in_entryRuleRequireStmt430 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRequireStmt437 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group__0_in_ruleRequireStmt463 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleReturnStmt_in_entryRuleReturnStmt490 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleReturnStmt497 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group__0_in_ruleReturnStmt523 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThrowStmt_in_entryRuleThrowStmt550 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleThrowStmt557 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ThrowStmt__Group__0_in_ruleThrowStmt583 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_entryRuleSuperClass610 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleSuperClass617 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__SuperClass__Alternatives_in_ruleSuperClass643 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleClassDeclaration_in_entryRuleClassDeclaration670 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleClassDeclaration677 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group__0_in_ruleClassDeclaration703 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignedClassDeclaration_in_entryRuleAssignedClassDeclaration730 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignedClassDeclaration737 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group__0_in_ruleAssignedClassDeclaration763 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_entryRuleExpression790 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleExpression797 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePostfix_in_ruleExpression823 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePostfix_in_entryRulePostfix849 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRulePostfix856 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group__0_in_rulePostfix882 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForBody_in_entryRuleForBody909 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleForBody916 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__Group__0_in_ruleForBody942 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForValue_in_entryRuleForValue969 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleForValue976 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleForValue1002 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForSource_in_entryRuleForSource1028 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleForSource1035 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group__0_in_ruleForSource1061 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRange_in_entryRuleRange1088 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRange1095 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group__0_in_ruleRange1121 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignment_in_entryRuleAssignment1148 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignment1155 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Alternatives_in_ruleAssignment1181 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssigned_in_entryRuleAssigned1208 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssigned1215 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assigned__Alternatives_in_ruleAssigned1241 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLogicOp_in_entryRuleLogicOp1268 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLogicOp1275 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group__0_in_ruleLogicOp1301 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCompareOp_in_entryRuleCompareOp1328 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCompareOp1335 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group__0_in_ruleCompareOp1361 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRelationOp_in_entryRuleRelationOp1388 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRelationOp1395 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group__0_in_ruleRelationOp1421 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleShiftOp_in_entryRuleShiftOp1448 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleShiftOp1455 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group__0_in_ruleShiftOp1481 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAdditiveOp_in_entryRuleAdditiveOp1508 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAdditiveOp1515 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group__0_in_ruleAdditiveOp1541 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleMathOp_in_entryRuleMathOp1568 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleMathOp1575 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group__0_in_ruleMathOp1601 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleUnaryOp_in_entryRuleUnaryOp1628 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleUnaryOp1635 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Alternatives_in_ruleUnaryOp1661 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleApplication_in_entryRuleApplication1688 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleApplication1695 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Alternatives_in_ruleApplication1721 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleFeatureCall_in_entryRuleFeatureCall1748 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleFeatureCall1755 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__FeatureCall__Alternatives_in_ruleFeatureCall1781 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleFunctionCall_in_entryRuleFunctionCall1808 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleFunctionCall1815 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__0_in_ruleFunctionCall1841 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePropertyAccess_in_entryRulePropertyAccess1868 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRulePropertyAccess1875 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PropertyAccess__Alternatives_in_rulePropertyAccess1901 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThisProperty_in_entryRuleThisProperty1928 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleThisProperty1935 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ThisProperty__Group__0_in_ruleThisProperty1961 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNamedPropertyAccess_in_entryRuleNamedPropertyAccess1988 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleNamedPropertyAccess1995 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__Alternatives_in_ruleNamedPropertyAccess2021 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndexedPropertyAccess_in_entryRuleIndexedPropertyAccess2048 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIndexedPropertyAccess2055 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IndexedPropertyAccess__Group__0_in_ruleIndexedPropertyAccess2081 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndex_in_entryRuleIndex2108 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIndex2115 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Alternatives_in_ruleIndex2141 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePrimaryExpression_in_entryRulePrimaryExpression2168 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRulePrimaryExpression2175 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Alternatives_in_rulePrimaryExpression2201 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_entryRuleBlock2228 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleBlock2235 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Block__Group__0_in_ruleBlock2261 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCase_in_entryRuleCase2288 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCase2295 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__Group__0_in_ruleCase2321 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIfExp_in_entryRuleIfExp2348 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIfExp2355 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group__0_in_ruleIfExp2381 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCondBlock_in_entryRuleCondBlock2408 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCondBlock2415 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CondBlock__Group__0_in_ruleCondBlock2441 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_entryRuleIdRef2468 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIdRef2475 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IdRef__ValAssignment_in_ruleIdRef2501 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_entryRuleId2528 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleId2535 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Id__NameAssignment_in_ruleId2561 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_entryRuleProperty2588 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleProperty2595 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Alternatives_in_ruleProperty2621 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleVariable_in_entryRuleVariable2648 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleVariable2655 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Alternatives_in_ruleVariable2681 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArray_in_entryRuleAssignableArray2708 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignableArray2715 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArray__Group__0_in_ruleAssignableArray2741 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArgList_in_entryRuleAssignableArgList2768 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignableArgList2775 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__Group__0_in_ruleAssignableArgList2801 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArg_in_entryRuleAssignableArg2828 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignableArg2835 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArg__Group__0_in_ruleAssignableArg2861 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_entryRuleAssignable2888 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignable2895 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignable__Alternatives_in_ruleAssignable2921 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArg_in_entryRuleArg2948 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArg2955 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Arg__Group__0_in_ruleArg2981 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgLine_in_entryRuleArgLine3008 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArgLine3015 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgLine__Group__0_in_ruleArgLine3041 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitArgList_in_entryRuleExplicitArgList3068 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleExplicitArgList3075 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group__0_in_ruleExplicitArgList3101 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgList_in_entryRuleArgList3128 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArgList3135 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__Group__0_in_ruleArgList3161 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArray_in_entryRuleArray3188 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArray3195 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Array__Group__0_in_ruleArray3221 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_entryRuleDictionary3248 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictionary3255 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Dictionary__Group__0_in_ruleDictionary3281 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItems_in_entryRuleDictItems3308 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictItems3315 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__Group__0_in_ruleDictItems3341 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitDictItems_in_entryRuleExplicitDictItems3368 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleExplicitDictItems3375 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group__0_in_ruleExplicitDictItems3401 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictLine_in_entryRuleDictLine3428 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictLine3435 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictLine__Group__0_in_ruleDictLine3461 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItem_in_entryRuleDictItem3488 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictItem3495 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group__0_in_ruleDictItem3521 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictKey_in_entryRuleDictKey3548 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictKey3555 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictKey__Alternatives_in_ruleDictKey3581 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLambda_in_entryRuleLambda3608 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLambda3615 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group__0_in_ruleLambda3641 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParam_in_entryRuleParam3668 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleParam3675 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__Group__0_in_ruleParam3701 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNumberLiteral_in_entryRuleNumberLiteral3728 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleNumberLiteral3735 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NumberLiteral__Group__0_in_ruleNumberLiteral3761 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_entryRuleStringLiteral3788 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleStringLiteral3795 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__StringLiteral__Group__0_in_ruleStringLiteral3821 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBoolLiteral_in_entryRuleBoolLiteral3848 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleBoolLiteral3855 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__BoolLiteral__Group__0_in_ruleBoolLiteral3881 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleJSLiteral_in_entryRuleJSLiteral3908 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleJSLiteral3915 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__JSLiteral__Group__0_in_ruleJSLiteral3941 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRegexLiteral_in_entryRuleRegexLiteral3968 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRegexLiteral3975 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RegexLiteral__Group__0_in_ruleRegexLiteral4001 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLiteral_in_entryRuleLiteral4028 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLiteral4035 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Literal__Alternatives_in_ruleLiteral4061 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParenthetical_in_entryRuleParenthetical4088 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleParenthetical4095 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Alternatives_in_ruleParenthetical4121 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStmt_in_rule__Line__Alternatives4158 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Line__Alternatives4175 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleReturnStmt_in_rule__Stmt__Alternatives4207 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThrowStmt_in_rule__Stmt__Alternatives4224 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRequireStmt_in_rule__Stmt__Alternatives4242 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleComment_in_rule__Stmt__Alternatives4260 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleClassDeclaration_in_rule__Stmt__Alternatives4277 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Stmt__StatementAssignment_5_in_rule__Stmt__Alternatives4294 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_rule__SuperClass__Alternatives4327 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_rule__SuperClass__Alternatives4344 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__BodyAssignment_2_0_in_rule__ClassDeclaration__Alternatives_24376 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_1__0_in_rule__ClassDeclaration__Alternatives_24394 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2__0_in_rule__ClassDeclaration__Alternatives_24412 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__ClassDeclaration__NameAlternatives_2_2_0_04445 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_rule__ClassDeclaration__NameAlternatives_2_2_0_04462 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_0__0_in_rule__AssignedClassDeclaration__Alternatives_24494 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1__0_in_rule__AssignedClassDeclaration__Alternatives_24512 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__AssignedClassDeclaration__NameAlternatives_2_1_0_04545 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_rule__AssignedClassDeclaration__NameAlternatives_2_1_0_04562 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_0__0_in_rule__Postfix__Alternatives_14594 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_1__0_in_rule__Postfix__Alternatives_14612 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2__0_in_rule__Postfix__Alternatives_14630 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3__0_in_rule__Postfix__Alternatives_14648 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0__0_in_rule__ForSource__Alternatives_14681 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1__0_in_rule__ForSource__Alternatives_14699 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0__0_in_rule__ForSource__Alternatives_1_1_24732 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1__0_in_rule__ForSource__Alternatives_1_1_24750 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_DOT_in_rule__Range__Alternatives_0_0_24783 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_rule__Range__Alternatives_0_0_24800 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0__0_in_rule__Assignment__Alternatives4832 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLogicOp_in_rule__Assignment__Alternatives4850 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_rule__Assignment__OperatorAlternatives_0_0_0_1_04882 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMPOUND_ASSIGN_in_rule__Assignment__OperatorAlternatives_0_0_0_1_04899 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Assigned__Alternatives4931 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assigned__Group_1__0_in_rule__Assigned__Alternatives4948 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignedClassDeclaration_in_rule__Assigned__Alternatives4966 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PLUS_in_rule__AdditiveOp__OperatorAlternatives_1_0_0_1_04998 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_MINUS_in_rule__AdditiveOp__OperatorAlternatives_1_0_0_1_05015 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_0__0_in_rule__UnaryOp__Alternatives5047 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_1__0_in_rule__UnaryOp__Alternatives5065 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_2__0_in_rule__UnaryOp__Alternatives5083 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNARY_in_rule__UnaryOp__Alternatives_0_05116 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PLUS_in_rule__UnaryOp__Alternatives_0_05133 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_MINUS_in_rule__UnaryOp__Alternatives_0_05150 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PLUS_PLUS_in_rule__UnaryOp__Alternatives_1_05182 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_MINUS_MINUS_in_rule__UnaryOp__Alternatives_1_05199 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0__0_in_rule__Application__Alternatives5231 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_1__0_in_rule__Application__Alternatives5249 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleFunctionCall_in_rule__FeatureCall__Alternatives5282 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePropertyAccess_in_rule__FeatureCall__Alternatives5299 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNamedPropertyAccess_in_rule__PropertyAccess__Alternatives5331 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndexedPropertyAccess_in_rule__PropertyAccess__Alternatives5348 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__Group_0__0_in_rule__NamedPropertyAccess__Alternatives5380 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__Group_1__0_in_rule__NamedPropertyAccess__Alternatives5398 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_in_rule__NamedPropertyAccess__AccessorAlternatives_0_0_05431 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_QUESTION_DOT_in_rule__NamedPropertyAccess__AccessorAlternatives_0_0_05448 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_0__0_in_rule__Index__Alternatives5480 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_1__0_in_rule__Index__Alternatives5498 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__ExpAssignment_2_in_rule__Index__Alternatives5516 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_DOT_in_rule__Index__DotsAlternatives_0_0_05549 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_rule__Index__DotsAlternatives_0_0_05566 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_DOT_in_rule__Index__DotsAlternatives_1_0_0_1_05598 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_rule__Index__DotsAlternatives_1_0_0_1_05615 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIfExp_in_rule__PrimaryExpression__Alternatives5647 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParenthetical_in_rule__PrimaryExpression__Alternatives5664 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLiteral_in_rule__PrimaryExpression__Alternatives5681 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRange_in_rule__PrimaryExpression__Alternatives5699 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArray_in_rule__PrimaryExpression__Alternatives5718 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_rule__PrimaryExpression__Alternatives5737 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLambda_in_rule__PrimaryExpression__Alternatives5755 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThisProperty_in_rule__PrimaryExpression__Alternatives5772 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_8__0_in_rule__PrimaryExpression__Alternatives5789 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9__0_in_rule__PrimaryExpression__Alternatives5807 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10__0_in_rule__PrimaryExpression__Alternatives5825 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11__0_in_rule__PrimaryExpression__Alternatives5843 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_12__0_in_rule__PrimaryExpression__Alternatives5861 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13__0_in_rule__PrimaryExpression__Alternatives5879 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14__0_in_rule__PrimaryExpression__Alternatives5897 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_rule__PrimaryExpression__Alternatives5915 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__0_in_rule__PrimaryExpression__Alternatives_13_1_25947 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_1__0_in_rule__PrimaryExpression__Alternatives_13_1_25965 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_0__0_in_rule__Property__Alternatives5998 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_1__0_in_rule__Property__Alternatives6016 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_in_rule__Property__AccessorAlternatives_0_0_0_1_06049 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOUBLE_COLON_in_rule__Property__AccessorAlternatives_0_0_0_1_06066 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_QUESTION_DOT_in_rule__Property__AccessorAlternatives_0_0_0_1_06083 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__Variable__Alternatives6115 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1__0_in_rule__Variable__Alternatives6132 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_rule__Variable__Alternatives6150 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_AT_SIGIL_in_rule__Variable__Alternatives_1_06182 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1_0_1__0_in_rule__Variable__Alternatives_1_06199 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleVariable_in_rule__Assignable__Alternatives6232 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_rule__Assignable__Alternatives6250 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArray_in_rule__Assignable__Alternatives6269 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_0__0_in_rule__ExplicitArgList__Alternatives_16302 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_1__0_in_rule__ExplicitArgList__Alternatives_16320 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__DummyAssignment_1_0_in_rule__ArgList__Alternatives_16353 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__Group_1_1__0_in_rule__ArgList__Alternatives_16371 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__DummyAssignment_1_0_in_rule__DictItems__Alternatives_16404 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__Group_1_1__0_in_rule__DictItems__Alternatives_16422 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_0__0_in_rule__ExplicitDictItems__Alternatives_16455 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_1__0_in_rule__ExplicitDictItems__Alternatives_16473 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__ValueAssignment_2_1_0_in_rule__DictItem__Alternatives_2_16506 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2_1_1__0_in_rule__DictItem__Alternatives_2_16524 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLiteral_in_rule__DictKey__Alternatives6557 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__DictKey__Alternatives6574 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FUNC_ARROW_in_rule__Lambda__Alternatives_16606 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BOUND_FUNC_ARROW_in_rule__Lambda__Alternatives_16623 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__Param__Alternatives_06655 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArray_in_rule__Param__Alternatives_06673 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_rule__Param__Alternatives_06692 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThisProperty_in_rule__Param__Alternatives_06710 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__SplatAssignment_1_0_in_rule__Param__Alternatives_16742 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__Group_1_1__0_in_rule__Param__Alternatives_16760 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNumberLiteral_in_rule__Literal__Alternatives6793 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_rule__Literal__Alternatives6810 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBoolLiteral_in_rule__Literal__Alternatives6827 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleJSLiteral_in_rule__Literal__Alternatives6844 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRegexLiteral_in_rule__Literal__Alternatives6861 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0__0_in_rule__Parenthetical__Alternatives6893 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_1__0_in_rule__Parenthetical__Alternatives6911 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__0__Impl_in_rule__TaskDeclaration__Group__06942 = new BitSet(new long[]{0x0000000000100000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__1_in_rule__TaskDeclaration__Group__06945 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TASK_in_rule__TaskDeclaration__Group__0__Impl6972 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__1__Impl_in_rule__TaskDeclaration__Group__17001 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__2_in_rule__TaskDeclaration__Group__17004 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_rule__TaskDeclaration__Group__1__Impl7031 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__2__Impl_in_rule__TaskDeclaration__Group__27060 = new BitSet(new long[]{0x0000000000200000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__3_in_rule__TaskDeclaration__Group__27063 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__NameAssignment_2_in_rule__TaskDeclaration__Group__2__Impl7090 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__3__Impl_in_rule__TaskDeclaration__Group__37120 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__4_in_rule__TaskDeclaration__Group__37123 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__TaskDeclaration__Group__3__Impl7150 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__4__Impl_in_rule__TaskDeclaration__Group__47179 = new BitSet(new long[]{0x0000000000200000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__5_in_rule__TaskDeclaration__Group__47182 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__DescriptionAssignment_4_in_rule__TaskDeclaration__Group__4__Impl7209 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__5__Impl_in_rule__TaskDeclaration__Group__57239 = new BitSet(new long[]{0x0000000001020000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__6_in_rule__TaskDeclaration__Group__57242 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__TaskDeclaration__Group__5__Impl7269 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__6__Impl_in_rule__TaskDeclaration__Group__67298 = new BitSet(new long[]{0x0000000001020000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__7_in_rule__TaskDeclaration__Group__67301 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group_6__0_in_rule__TaskDeclaration__Group__6__Impl7328 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__7__Impl_in_rule__TaskDeclaration__Group__77359 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__8_in_rule__TaskDeclaration__Group__77362 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FUNC_ARROW_in_rule__TaskDeclaration__Group__7__Impl7389 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__8__Impl_in_rule__TaskDeclaration__Group__87418 = new BitSet(new long[]{0x0000000000400000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__9_in_rule__TaskDeclaration__Group__87421 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__BodyAssignment_8_in_rule__TaskDeclaration__Group__8__Impl7448 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__9__Impl_in_rule__TaskDeclaration__Group__97478 = new BitSet(new long[]{0x0000000000800000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__10_in_rule__TaskDeclaration__Group__97481 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_rule__TaskDeclaration__Group__9__Impl7508 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group__10__Impl_in_rule__TaskDeclaration__Group__107537 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_rule__TaskDeclaration__Group__10__Impl7564 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group_6__0__Impl_in_rule__TaskDeclaration__Group_6__07615 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group_6__1_in_rule__TaskDeclaration__Group_6__07618 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PARAM_START_in_rule__TaskDeclaration__Group_6__0__Impl7645 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group_6__1__Impl_in_rule__TaskDeclaration__Group_6__17674 = new BitSet(new long[]{0x0000000002000000L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group_6__2_in_rule__TaskDeclaration__Group_6__17677 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__OptionsAssignment_6_1_in_rule__TaskDeclaration__Group_6__1__Impl7704 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__TaskDeclaration__Group_6__2__Impl_in_rule__TaskDeclaration__Group_6__27734 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PARAM_END_in_rule__TaskDeclaration__Group_6__2__Impl7761 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Body__Group__0__Impl_in_rule__Body__Group__07797 = new BitSet(new long[]{0x0000000000800000L});
+ public static final BitSet FOLLOW_rule__Body__Group__1_in_rule__Body__Group__07800 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Body__LinesAssignment_0_in_rule__Body__Group__0__Impl7827 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Body__Group__1__Impl_in_rule__Body__Group__17857 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Body__Group_1__0_in_rule__Body__Group__1__Impl7884 = new BitSet(new long[]{0x0000000000800002L});
+ public static final BitSet FOLLOW_rule__Body__Group_1__0__Impl_in_rule__Body__Group_1__07919 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Body__Group_1__1_in_rule__Body__Group_1__07922 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_rule__Body__Group_1__0__Impl7949 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Body__Group_1__1__Impl_in_rule__Body__Group_1__17978 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Body__LinesAssignment_1_1_in_rule__Body__Group_1__1__Impl8005 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group__0__Impl_in_rule__RequireStmt__Group__08040 = new BitSet(new long[]{0x0000000000100000L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group__1_in_rule__RequireStmt__Group__08043 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group_0__0_in_rule__RequireStmt__Group__0__Impl8070 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group__1__Impl_in_rule__RequireStmt__Group__18100 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group__2_in_rule__RequireStmt__Group__18103 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_rule__RequireStmt__Group__1__Impl8130 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group__2__Impl_in_rule__RequireStmt__Group__28159 = new BitSet(new long[]{0x0000000000400000L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group__3_in_rule__RequireStmt__Group__28162 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__UriAssignment_2_in_rule__RequireStmt__Group__2__Impl8189 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group__3__Impl_in_rule__RequireStmt__Group__38219 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_rule__RequireStmt__Group__3__Impl8246 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group_0__0__Impl_in_rule__RequireStmt__Group_0__08283 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group_0_0__0_in_rule__RequireStmt__Group_0__0__Impl8310 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group_0_0__0__Impl_in_rule__RequireStmt__Group_0_0__08342 = new BitSet(new long[]{0x0000000000000040L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group_0_0__1_in_rule__RequireStmt__Group_0_0__08345 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__ImportedNamespaceAssignment_0_0_0_in_rule__RequireStmt__Group_0_0__0__Impl8372 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group_0_0__1__Impl_in_rule__RequireStmt__Group_0_0__18402 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group_0_0__2_in_rule__RequireStmt__Group_0_0__18405 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_rule__RequireStmt__Group_0_0__1__Impl8432 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RequireStmt__Group_0_0__2__Impl_in_rule__RequireStmt__Group_0_0__28461 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_86_in_rule__RequireStmt__Group_0_0__2__Impl8489 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group__0__Impl_in_rule__ReturnStmt__Group__08526 = new BitSet(new long[]{0x0000000004000000L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group__1_in_rule__ReturnStmt__Group__08529 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group__1__Impl_in_rule__ReturnStmt__Group__18587 = new BitSet(new long[]{0xF9271105BD071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group__2_in_rule__ReturnStmt__Group__18590 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RETURN_in_rule__ReturnStmt__Group__1__Impl8617 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group__2__Impl_in_rule__ReturnStmt__Group__28646 = new BitSet(new long[]{0xF9271105BD071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group__3_in_rule__ReturnStmt__Group__28649 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__ExpressionAssignment_2_in_rule__ReturnStmt__Group__2__Impl8676 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group__3__Impl_in_rule__ReturnStmt__Group__38707 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group_3__0_in_rule__ReturnStmt__Group__3__Impl8734 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group_3__0__Impl_in_rule__ReturnStmt__Group_3__08773 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group_3__1_in_rule__ReturnStmt__Group_3__08776 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_POST_IF_in_rule__ReturnStmt__Group_3__0__Impl8803 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__Group_3__1__Impl_in_rule__ReturnStmt__Group_3__18832 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ReturnStmt__ConditionAssignment_3_1_in_rule__ReturnStmt__Group_3__1__Impl8859 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ThrowStmt__Group__0__Impl_in_rule__ThrowStmt__Group__08893 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ThrowStmt__Group__1_in_rule__ThrowStmt__Group__08896 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_THROW_in_rule__ThrowStmt__Group__0__Impl8923 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ThrowStmt__Group__1__Impl_in_rule__ThrowStmt__Group__18952 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ThrowStmt__ExpAssignment_1_in_rule__ThrowStmt__Group__1__Impl8979 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group__0__Impl_in_rule__ClassDeclaration__Group__09013 = new BitSet(new long[]{0x0000000020000000L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group__1_in_rule__ClassDeclaration__Group__09016 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group__1__Impl_in_rule__ClassDeclaration__Group__19074 = new BitSet(new long[]{0x0001020040010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group__2_in_rule__ClassDeclaration__Group__19077 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CLASS_in_rule__ClassDeclaration__Group__1__Impl9104 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group__2__Impl_in_rule__ClassDeclaration__Group__29133 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Alternatives_2_in_rule__ClassDeclaration__Group__2__Impl9160 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_1__0__Impl_in_rule__ClassDeclaration__Group_2_1__09197 = new BitSet(new long[]{0x0001000000010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_1__1_in_rule__ClassDeclaration__Group_2_1__09200 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_rule__ClassDeclaration__Group_2_1__0__Impl9227 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_1__1__Impl_in_rule__ClassDeclaration__Group_2_1__19256 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_1__2_in_rule__ClassDeclaration__Group_2_1__19259 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__ExtendAssignment_2_1_1_in_rule__ClassDeclaration__Group_2_1__1__Impl9286 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_1__2__Impl_in_rule__ClassDeclaration__Group_2_1__29316 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__BodyAssignment_2_1_2_in_rule__ClassDeclaration__Group_2_1__2__Impl9343 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2__0__Impl_in_rule__ClassDeclaration__Group_2_2__09380 = new BitSet(new long[]{0x0000020040000000L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2__1_in_rule__ClassDeclaration__Group_2_2__09383 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__NameAssignment_2_2_0_in_rule__ClassDeclaration__Group_2_2__0__Impl9410 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2__1__Impl_in_rule__ClassDeclaration__Group_2_2__19440 = new BitSet(new long[]{0x0000020040000000L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2__2_in_rule__ClassDeclaration__Group_2_2__19443 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2_1__0_in_rule__ClassDeclaration__Group_2_2__1__Impl9470 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2__2__Impl_in_rule__ClassDeclaration__Group_2_2__29501 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__BodyAssignment_2_2_2_in_rule__ClassDeclaration__Group_2_2__2__Impl9528 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2_1__0__Impl_in_rule__ClassDeclaration__Group_2_2_1__09564 = new BitSet(new long[]{0x0001000000010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2_1__1_in_rule__ClassDeclaration__Group_2_2_1__09567 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_rule__ClassDeclaration__Group_2_2_1__0__Impl9594 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__Group_2_2_1__1__Impl_in_rule__ClassDeclaration__Group_2_2_1__19623 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__ExtendAssignment_2_2_1_1_in_rule__ClassDeclaration__Group_2_2_1__1__Impl9650 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group__0__Impl_in_rule__AssignedClassDeclaration__Group__09684 = new BitSet(new long[]{0x0000000020000000L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group__1_in_rule__AssignedClassDeclaration__Group__09687 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group__1__Impl_in_rule__AssignedClassDeclaration__Group__19745 = new BitSet(new long[]{0x0001000040010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group__2_in_rule__AssignedClassDeclaration__Group__19748 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CLASS_in_rule__AssignedClassDeclaration__Group__1__Impl9775 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group__2__Impl_in_rule__AssignedClassDeclaration__Group__29804 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Alternatives_2_in_rule__AssignedClassDeclaration__Group__2__Impl9831 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_0__0__Impl_in_rule__AssignedClassDeclaration__Group_2_0__09868 = new BitSet(new long[]{0x0001000000010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_0__1_in_rule__AssignedClassDeclaration__Group_2_0__09871 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_rule__AssignedClassDeclaration__Group_2_0__0__Impl9898 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_0__1__Impl_in_rule__AssignedClassDeclaration__Group_2_0__19927 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_0__2_in_rule__AssignedClassDeclaration__Group_2_0__19930 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__ExtendAssignment_2_0_1_in_rule__AssignedClassDeclaration__Group_2_0__1__Impl9957 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_0__2__Impl_in_rule__AssignedClassDeclaration__Group_2_0__29987 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__BodyAssignment_2_0_2_in_rule__AssignedClassDeclaration__Group_2_0__2__Impl10014 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1__0__Impl_in_rule__AssignedClassDeclaration__Group_2_1__010050 = new BitSet(new long[]{0x0000020040000000L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1__1_in_rule__AssignedClassDeclaration__Group_2_1__010053 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__NameAssignment_2_1_0_in_rule__AssignedClassDeclaration__Group_2_1__0__Impl10080 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1__1__Impl_in_rule__AssignedClassDeclaration__Group_2_1__110110 = new BitSet(new long[]{0x0000020040000000L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1__2_in_rule__AssignedClassDeclaration__Group_2_1__110113 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1_1__0_in_rule__AssignedClassDeclaration__Group_2_1__1__Impl10140 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1__2__Impl_in_rule__AssignedClassDeclaration__Group_2_1__210171 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__BodyAssignment_2_1_2_in_rule__AssignedClassDeclaration__Group_2_1__2__Impl10198 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1_1__0__Impl_in_rule__AssignedClassDeclaration__Group_2_1_1__010234 = new BitSet(new long[]{0x0001000000010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1_1__1_in_rule__AssignedClassDeclaration__Group_2_1_1__010237 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_rule__AssignedClassDeclaration__Group_2_1_1__0__Impl10264 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__Group_2_1_1__1__Impl_in_rule__AssignedClassDeclaration__Group_2_1_1__110293 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_1_in_rule__AssignedClassDeclaration__Group_2_1_1__1__Impl10320 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group__0__Impl_in_rule__Postfix__Group__010354 = new BitSet(new long[]{0x0000000588000000L});
+ public static final BitSet FOLLOW_rule__Postfix__Group__1_in_rule__Postfix__Group__010357 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignment_in_rule__Postfix__Group__0__Impl10384 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group__1__Impl_in_rule__Postfix__Group__110413 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Alternatives_1_in_rule__Postfix__Group__1__Impl10440 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_0__0__Impl_in_rule__Postfix__Group_1_0__010475 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_0__1_in_rule__Postfix__Group_1_0__010478 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_POST_IF_in_rule__Postfix__Group_1_0__0__Impl10506 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_0__1__Impl_in_rule__Postfix__Group_1_0__110536 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_0__2_in_rule__Postfix__Group_1_0__110539 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_0__2__Impl_in_rule__Postfix__Group_1_0__210597 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__ConditionAssignment_1_0_2_in_rule__Postfix__Group_1_0__2__Impl10624 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_1__0__Impl_in_rule__Postfix__Group_1_1__010660 = new BitSet(new long[]{0x0000000800000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_1__1_in_rule__Postfix__Group_1_1__010663 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOR_in_rule__Postfix__Group_1_1__0__Impl10691 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_1__1__Impl_in_rule__Postfix__Group_1_1__110721 = new BitSet(new long[]{0x0000000800000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_1__2_in_rule__Postfix__Group_1_1__110724 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_1__2__Impl_in_rule__Postfix__Group_1_1__210782 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__BodyAssignment_1_1_2_in_rule__Postfix__Group_1_1__2__Impl10809 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2__0__Impl_in_rule__Postfix__Group_1_2__010845 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2__1_in_rule__Postfix__Group_1_2__010848 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHILE_in_rule__Postfix__Group_1_2__0__Impl10876 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2__1__Impl_in_rule__Postfix__Group_1_2__110906 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2__2_in_rule__Postfix__Group_1_2__110909 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2__2__Impl_in_rule__Postfix__Group_1_2__210967 = new BitSet(new long[]{0x0000000200000000L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2__3_in_rule__Postfix__Group_1_2__210970 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__BodyAssignment_1_2_2_in_rule__Postfix__Group_1_2__2__Impl10997 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2__3__Impl_in_rule__Postfix__Group_1_2__311027 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2_3__0_in_rule__Postfix__Group_1_2__3__Impl11054 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2_3__0__Impl_in_rule__Postfix__Group_1_2_3__011093 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2_3__1_in_rule__Postfix__Group_1_2_3__011096 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rule__Postfix__Group_1_2_3__0__Impl11124 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2_3__1__Impl_in_rule__Postfix__Group_1_2_3__111154 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__WhenAssignment_1_2_3_1_in_rule__Postfix__Group_1_2_3__1__Impl11181 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3__0__Impl_in_rule__Postfix__Group_1_3__011215 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3__1_in_rule__Postfix__Group_1_3__011218 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNTIL_in_rule__Postfix__Group_1_3__0__Impl11246 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3__1__Impl_in_rule__Postfix__Group_1_3__111276 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3__2_in_rule__Postfix__Group_1_3__111279 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3__2__Impl_in_rule__Postfix__Group_1_3__211337 = new BitSet(new long[]{0x0000000200000000L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3__3_in_rule__Postfix__Group_1_3__211340 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__BodyAssignment_1_3_2_in_rule__Postfix__Group_1_3__2__Impl11367 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3__3__Impl_in_rule__Postfix__Group_1_3__311397 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3_3__0_in_rule__Postfix__Group_1_3__3__Impl11424 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3_3__0__Impl_in_rule__Postfix__Group_1_3_3__011463 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3_3__1_in_rule__Postfix__Group_1_3_3__011466 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rule__Postfix__Group_1_3_3__0__Impl11494 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3_3__1__Impl_in_rule__Postfix__Group_1_3_3__111524 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__WhenAssignment_1_3_3_1_in_rule__Postfix__Group_1_3_3__1__Impl11551 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__Group__0__Impl_in_rule__ForBody__Group__011585 = new BitSet(new long[]{0x0000000800000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__ForBody__Group__1_in_rule__ForBody__Group__011588 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OWN_in_rule__ForBody__Group__0__Impl11616 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__Group__1__Impl_in_rule__ForBody__Group__111647 = new BitSet(new long[]{0x0000003000200000L});
+ public static final BitSet FOLLOW_rule__ForBody__Group__2_in_rule__ForBody__Group__111650 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__IndexesAssignment_1_in_rule__ForBody__Group__1__Impl11677 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__Group__2__Impl_in_rule__ForBody__Group__211707 = new BitSet(new long[]{0x0000003000200000L});
+ public static final BitSet FOLLOW_rule__ForBody__Group__3_in_rule__ForBody__Group__211710 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__Group_2__0_in_rule__ForBody__Group__2__Impl11737 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_rule__ForBody__Group__3__Impl_in_rule__ForBody__Group__311768 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__SourceAssignment_3_in_rule__ForBody__Group__3__Impl11795 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__Group_2__0__Impl_in_rule__ForBody__Group_2__011833 = new BitSet(new long[]{0x0000000800000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__ForBody__Group_2__1_in_rule__ForBody__Group_2__011836 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__ForBody__Group_2__0__Impl11863 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__Group_2__1__Impl_in_rule__ForBody__Group_2__111892 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForBody__IndexesAssignment_2_1_in_rule__ForBody__Group_2__1__Impl11919 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group__0__Impl_in_rule__ForSource__Group__011953 = new BitSet(new long[]{0x0000003000200000L});
+ public static final BitSet FOLLOW_rule__ForSource__Group__1_in_rule__ForSource__Group__011956 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group__1__Impl_in_rule__ForSource__Group__112014 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Alternatives_1_in_rule__ForSource__Group__1__Impl12041 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0__0__Impl_in_rule__ForSource__Group_1_0__012075 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0__1_in_rule__ForSource__Group_1_0__012078 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOROF_in_rule__ForSource__Group_1_0__0__Impl12106 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0__1__Impl_in_rule__ForSource__Group_1_0__112136 = new BitSet(new long[]{0x0000000200000000L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0__2_in_rule__ForSource__Group_1_0__112139 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__SourceAssignment_1_0_1_in_rule__ForSource__Group_1_0__1__Impl12166 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0__2__Impl_in_rule__ForSource__Group_1_0__212196 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0_2__0_in_rule__ForSource__Group_1_0__2__Impl12223 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0_2__0__Impl_in_rule__ForSource__Group_1_0_2__012260 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0_2__1_in_rule__ForSource__Group_1_0_2__012263 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rule__ForSource__Group_1_0_2__0__Impl12291 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0_2__1__Impl_in_rule__ForSource__Group_1_0_2__112321 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__WhenAssignment_1_0_2_1_in_rule__ForSource__Group_1_0_2__1__Impl12348 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1__0__Impl_in_rule__ForSource__Group_1_1__012382 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1__1_in_rule__ForSource__Group_1_1__012385 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FORIN_in_rule__ForSource__Group_1_1__0__Impl12413 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1__1__Impl_in_rule__ForSource__Group_1_1__112443 = new BitSet(new long[]{0x0000004200000000L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1__2_in_rule__ForSource__Group_1_1__112446 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__SourceAssignment_1_1_1_in_rule__ForSource__Group_1_1__1__Impl12473 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1__2__Impl_in_rule__ForSource__Group_1_1__212503 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Alternatives_1_1_2_in_rule__ForSource__Group_1_1__2__Impl12530 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0__0__Impl_in_rule__ForSource__Group_1_1_2_0__012567 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0__1_in_rule__ForSource__Group_1_1_2_0__012570 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rule__ForSource__Group_1_1_2_0__0__Impl12598 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0__1__Impl_in_rule__ForSource__Group_1_1_2_0__112628 = new BitSet(new long[]{0x0000004000000000L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0__2_in_rule__ForSource__Group_1_1_2_0__112631 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__WhenAssignment_1_1_2_0_1_in_rule__ForSource__Group_1_1_2_0__1__Impl12658 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0__2__Impl_in_rule__ForSource__Group_1_1_2_0__212688 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0_2__0_in_rule__ForSource__Group_1_1_2_0__2__Impl12715 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0_2__0__Impl_in_rule__ForSource__Group_1_1_2_0_2__012752 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0_2__1_in_rule__ForSource__Group_1_1_2_0_2__012755 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_rule__ForSource__Group_1_1_2_0_2__0__Impl12783 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0_2__1__Impl_in_rule__ForSource__Group_1_1_2_0_2__112813 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__ByAssignment_1_1_2_0_2_1_in_rule__ForSource__Group_1_1_2_0_2__1__Impl12840 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1__0__Impl_in_rule__ForSource__Group_1_1_2_1__012874 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1__1_in_rule__ForSource__Group_1_1_2_1__012877 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_rule__ForSource__Group_1_1_2_1__0__Impl12905 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1__1__Impl_in_rule__ForSource__Group_1_1_2_1__112935 = new BitSet(new long[]{0x0000000200000000L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1__2_in_rule__ForSource__Group_1_1_2_1__112938 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__ByAssignment_1_1_2_1_1_in_rule__ForSource__Group_1_1_2_1__1__Impl12965 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1__2__Impl_in_rule__ForSource__Group_1_1_2_1__212995 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1_2__0_in_rule__ForSource__Group_1_1_2_1__2__Impl13022 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1_2__0__Impl_in_rule__ForSource__Group_1_1_2_1_2__013059 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1_2__1_in_rule__ForSource__Group_1_1_2_1_2__013062 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rule__ForSource__Group_1_1_2_1_2__0__Impl13090 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1_2__1__Impl_in_rule__ForSource__Group_1_1_2_1_2__113120 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__WhenAssignment_1_1_2_1_2_1_in_rule__ForSource__Group_1_1_2_1_2__1__Impl13147 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group__0__Impl_in_rule__Range__Group__013181 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Range__Group__1_in_rule__Range__Group__013184 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group_0__0_in_rule__Range__Group__0__Impl13211 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group__1__Impl_in_rule__Range__Group__113241 = new BitSet(new long[]{0x0000008000000000L});
+ public static final BitSet FOLLOW_rule__Range__Group__2_in_rule__Range__Group__113244 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__EndAssignment_1_in_rule__Range__Group__1__Impl13271 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group__2__Impl_in_rule__Range__Group__213301 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RBRACKET_in_rule__Range__Group__2__Impl13328 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group_0__0__Impl_in_rule__Range__Group_0__013363 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group_0_0__0_in_rule__Range__Group_0__0__Impl13390 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group_0_0__0__Impl_in_rule__Range__Group_0_0__013422 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Range__Group_0_0__1_in_rule__Range__Group_0_0__013425 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_rule__Range__Group_0_0__0__Impl13452 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group_0_0__1__Impl_in_rule__Range__Group_0_0__113481 = new BitSet(new long[]{0x0000000000000030L});
+ public static final BitSet FOLLOW_rule__Range__Group_0_0__2_in_rule__Range__Group_0_0__113484 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__StartAssignment_0_0_1_in_rule__Range__Group_0_0__1__Impl13511 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Group_0_0__2__Impl_in_rule__Range__Group_0_0__213541 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Range__Alternatives_0_0_2_in_rule__Range__Group_0_0__2__Impl13568 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0__0__Impl_in_rule__Assignment__Group_0__013604 = new BitSet(new long[]{0xF9271305B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0__1_in_rule__Assignment__Group_0__013607 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0_0__0_in_rule__Assignment__Group_0__0__Impl13634 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0__1__Impl_in_rule__Assignment__Group_0__113664 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__RightAssignment_0_1_in_rule__Assignment__Group_0__1__Impl13691 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0_0__0__Impl_in_rule__Assignment__Group_0_0__013725 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0_0_0__0_in_rule__Assignment__Group_0_0__0__Impl13752 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0_0_0__0__Impl_in_rule__Assignment__Group_0_0_0__013784 = new BitSet(new long[]{0x00000000000000C0L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0_0_0__1_in_rule__Assignment__Group_0_0_0__013787 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__LeftAssignment_0_0_0_0_in_rule__Assignment__Group_0_0_0__0__Impl13814 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0_0_0__1__Impl_in_rule__Assignment__Group_0_0_0__113844 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__OperatorAssignment_0_0_0_1_in_rule__Assignment__Group_0_0_0__1__Impl13871 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assigned__Group_1__0__Impl_in_rule__Assigned__Group_1__013905 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Assigned__Group_1__1_in_rule__Assigned__Group_1__013908 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rule__Assigned__Group_1__0__Impl13935 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assigned__Group_1__1__Impl_in_rule__Assigned__Group_1__113964 = new BitSet(new long[]{0x0000040000000000L});
+ public static final BitSet FOLLOW_rule__Assigned__Group_1__2_in_rule__Assigned__Group_1__113967 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Assigned__Group_1__1__Impl13994 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assigned__Group_1__2__Impl_in_rule__Assigned__Group_1__214023 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rule__Assigned__Group_1__2__Impl14050 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group__0__Impl_in_rule__LogicOp__Group__014085 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group__1_in_rule__LogicOp__Group__014088 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCompareOp_in_rule__LogicOp__Group__0__Impl14115 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group__1__Impl_in_rule__LogicOp__Group__114144 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1__0_in_rule__LogicOp__Group__1__Impl14171 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000010L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1__0__Impl_in_rule__LogicOp__Group_1__014206 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1__1_in_rule__LogicOp__Group_1__014209 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1_0__0_in_rule__LogicOp__Group_1__0__Impl14236 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1__1__Impl_in_rule__LogicOp__Group_1__114266 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__RightAssignment_1_1_in_rule__LogicOp__Group_1__1__Impl14293 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1_0__0__Impl_in_rule__LogicOp__Group_1_0__014327 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1_0_0__0_in_rule__LogicOp__Group_1_0__0__Impl14354 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1_0_0__0__Impl_in_rule__LogicOp__Group_1_0_0__014386 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1_0_0__1_in_rule__LogicOp__Group_1_0_0__014389 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1_0_0__1__Impl_in_rule__LogicOp__Group_1_0_0__114447 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__OperatorAssignment_1_0_0_1_in_rule__LogicOp__Group_1_0_0__1__Impl14474 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group__0__Impl_in_rule__CompareOp__Group__014508 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group__1_in_rule__CompareOp__Group__014511 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRelationOp_in_rule__CompareOp__Group__0__Impl14538 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group__1__Impl_in_rule__CompareOp__Group__114567 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1__0_in_rule__CompareOp__Group__1__Impl14594 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1__0__Impl_in_rule__CompareOp__Group_1__014629 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1__1_in_rule__CompareOp__Group_1__014632 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1_0__0_in_rule__CompareOp__Group_1__0__Impl14659 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1__1__Impl_in_rule__CompareOp__Group_1__114689 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__RightAssignment_1_1_in_rule__CompareOp__Group_1__1__Impl14716 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1_0__0__Impl_in_rule__CompareOp__Group_1_0__014750 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1_0_0__0_in_rule__CompareOp__Group_1_0__0__Impl14777 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1_0_0__0__Impl_in_rule__CompareOp__Group_1_0_0__014809 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1_0_0__1_in_rule__CompareOp__Group_1_0_0__014812 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1_0_0__1__Impl_in_rule__CompareOp__Group_1_0_0__114870 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__OperatorAssignment_1_0_0_1_in_rule__CompareOp__Group_1_0_0__1__Impl14897 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group__0__Impl_in_rule__RelationOp__Group__014931 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group__1_in_rule__RelationOp__Group__014934 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleShiftOp_in_rule__RelationOp__Group__0__Impl14961 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group__1__Impl_in_rule__RelationOp__Group__114990 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1__0_in_rule__RelationOp__Group__1__Impl15017 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1__0__Impl_in_rule__RelationOp__Group_1__015052 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1__1_in_rule__RelationOp__Group_1__015055 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1_0__0_in_rule__RelationOp__Group_1__0__Impl15082 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1__1__Impl_in_rule__RelationOp__Group_1__115112 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__RightAssignment_1_1_in_rule__RelationOp__Group_1__1__Impl15139 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1_0__0__Impl_in_rule__RelationOp__Group_1_0__015173 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1_0_0__0_in_rule__RelationOp__Group_1_0__0__Impl15200 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1_0_0__0__Impl_in_rule__RelationOp__Group_1_0_0__015232 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1_0_0__1_in_rule__RelationOp__Group_1_0_0__015235 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1_0_0__1__Impl_in_rule__RelationOp__Group_1_0_0__115293 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__OperatorAssignment_1_0_0_1_in_rule__RelationOp__Group_1_0_0__1__Impl15320 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group__0__Impl_in_rule__ShiftOp__Group__015354 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group__1_in_rule__ShiftOp__Group__015357 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAdditiveOp_in_rule__ShiftOp__Group__0__Impl15384 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group__1__Impl_in_rule__ShiftOp__Group__115413 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1__0_in_rule__ShiftOp__Group__1__Impl15440 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1__0__Impl_in_rule__ShiftOp__Group_1__015475 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1__1_in_rule__ShiftOp__Group_1__015478 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1_0__0_in_rule__ShiftOp__Group_1__0__Impl15505 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1__1__Impl_in_rule__ShiftOp__Group_1__115535 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__RightAssignment_1_1_in_rule__ShiftOp__Group_1__1__Impl15562 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1_0__0__Impl_in_rule__ShiftOp__Group_1_0__015596 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1_0_0__0_in_rule__ShiftOp__Group_1_0__0__Impl15623 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1_0_0__0__Impl_in_rule__ShiftOp__Group_1_0_0__015655 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1_0_0__1_in_rule__ShiftOp__Group_1_0_0__015658 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1_0_0__1__Impl_in_rule__ShiftOp__Group_1_0_0__115716 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__OperatorAssignment_1_0_0_1_in_rule__ShiftOp__Group_1_0_0__1__Impl15743 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group__0__Impl_in_rule__AdditiveOp__Group__015777 = new BitSet(new long[]{0x0000000000000300L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group__1_in_rule__AdditiveOp__Group__015780 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleMathOp_in_rule__AdditiveOp__Group__0__Impl15807 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group__1__Impl_in_rule__AdditiveOp__Group__115836 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1__0_in_rule__AdditiveOp__Group__1__Impl15863 = new BitSet(new long[]{0x0000000000000302L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1__0__Impl_in_rule__AdditiveOp__Group_1__015898 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1__1_in_rule__AdditiveOp__Group_1__015901 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1_0__0_in_rule__AdditiveOp__Group_1__0__Impl15928 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1__1__Impl_in_rule__AdditiveOp__Group_1__115958 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__RightAssignment_1_1_in_rule__AdditiveOp__Group_1__1__Impl15985 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1_0__0__Impl_in_rule__AdditiveOp__Group_1_0__016019 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1_0_0__0_in_rule__AdditiveOp__Group_1_0__0__Impl16046 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1_0_0__0__Impl_in_rule__AdditiveOp__Group_1_0_0__016078 = new BitSet(new long[]{0x0000000000000300L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1_0_0__1_in_rule__AdditiveOp__Group_1_0_0__016081 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1_0_0__1__Impl_in_rule__AdditiveOp__Group_1_0_0__116139 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__OperatorAssignment_1_0_0_1_in_rule__AdditiveOp__Group_1_0_0__1__Impl16166 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group__0__Impl_in_rule__MathOp__Group__016200 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
+ public static final BitSet FOLLOW_rule__MathOp__Group__1_in_rule__MathOp__Group__016203 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleUnaryOp_in_rule__MathOp__Group__0__Impl16230 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group__1__Impl_in_rule__MathOp__Group__116259 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1__0_in_rule__MathOp__Group__1__Impl16286 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1__0__Impl_in_rule__MathOp__Group_1__016321 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1__1_in_rule__MathOp__Group_1__016324 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1_0__0_in_rule__MathOp__Group_1__0__Impl16351 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1__1__Impl_in_rule__MathOp__Group_1__116381 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__RightAssignment_1_1_in_rule__MathOp__Group_1__1__Impl16408 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1_0__0__Impl_in_rule__MathOp__Group_1_0__016442 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1_0_0__0_in_rule__MathOp__Group_1_0__0__Impl16469 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1_0_0__0__Impl_in_rule__MathOp__Group_1_0_0__016501 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1_0_0__1_in_rule__MathOp__Group_1_0_0__016504 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1_0_0__1__Impl_in_rule__MathOp__Group_1_0_0__116562 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__OperatorAssignment_1_0_0_1_in_rule__MathOp__Group_1_0_0__1__Impl16589 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_0__0__Impl_in_rule__UnaryOp__Group_0__016623 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_0__1_in_rule__UnaryOp__Group_0__016626 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Alternatives_0_0_in_rule__UnaryOp__Group_0__0__Impl16653 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_0__1__Impl_in_rule__UnaryOp__Group_0__116683 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__UnaryOp__Group_0__1__Impl16710 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_1__0__Impl_in_rule__UnaryOp__Group_1__016743 = new BitSet(new long[]{0x0001000000010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_1__1_in_rule__UnaryOp__Group_1__016746 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Alternatives_1_0_in_rule__UnaryOp__Group_1__0__Impl16773 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_1__1__Impl_in_rule__UnaryOp__Group_1__116803 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleVariable_in_rule__UnaryOp__Group_1__1__Impl16830 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_2__0__Impl_in_rule__UnaryOp__Group_2__016863 = new BitSet(new long[]{0x0000080000000000L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_2__1_in_rule__UnaryOp__Group_2__016866 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleApplication_in_rule__UnaryOp__Group_2__0__Impl16893 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__UnaryOp__Group_2__1__Impl_in_rule__UnaryOp__Group_2__116922 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_QUESTION_in_rule__UnaryOp__Group_2__1__Impl16950 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0__0__Impl_in_rule__Application__Group_0__016985 = new BitSet(new long[]{0x0000100000000000L});
+ public static final BitSet FOLLOW_rule__Application__Group_0__1_in_rule__Application__Group_0__016988 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0__1__Impl_in_rule__Application__Group_0__117046 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1__0_in_rule__Application__Group_0__1__Impl17073 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1__0__Impl_in_rule__Application__Group_0_1__017107 = new BitSet(new long[]{0x0000000000100000L});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1__1_in_rule__Application__Group_0_1__017110 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_SUPER_in_rule__Application__Group_0_1__0__Impl17137 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1__1__Impl_in_rule__Application__Group_0_1__117166 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1_1__0_in_rule__Application__Group_0_1__1__Impl17193 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1_1__0__Impl_in_rule__Application__Group_0_1_1__017228 = new BitSet(new long[]{0xF9271305B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1_1__1_in_rule__Application__Group_0_1_1__017231 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_rule__Application__Group_0_1_1__0__Impl17258 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1_1__1__Impl_in_rule__Application__Group_0_1_1__117287 = new BitSet(new long[]{0x0000000000400000L});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1_1__2_in_rule__Application__Group_0_1_1__117290 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__ArgsAssignment_0_1_1_1_in_rule__Application__Group_0_1_1__1__Impl17317 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_0_1_1__2__Impl_in_rule__Application__Group_0_1_1__217347 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_rule__Application__Group_0_1_1__2__Impl17374 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_1__0__Impl_in_rule__Application__Group_1__017409 = new BitSet(new long[]{0x000060000010E000L});
+ public static final BitSet FOLLOW_rule__Application__Group_1__1_in_rule__Application__Group_1__017412 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__ValueAssignment_1_0_in_rule__Application__Group_1__0__Impl17439 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__Group_1__1__Impl_in_rule__Application__Group_1__117469 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Application__FeaturesAssignment_1_1_in_rule__Application__Group_1__1__Impl17496 = new BitSet(new long[]{0x000060000010E002L});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__0__Impl_in_rule__FunctionCall__Group__017531 = new BitSet(new long[]{0x0000200000100000L});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__1_in_rule__FunctionCall__Group__017534 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__1__Impl_in_rule__FunctionCall__Group__117592 = new BitSet(new long[]{0x0000200000100000L});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__2_in_rule__FunctionCall__Group__117595 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FUNC_EXIST_in_rule__FunctionCall__Group__1__Impl17623 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__2__Impl_in_rule__FunctionCall__Group__217654 = new BitSet(new long[]{0xF9271305B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__3_in_rule__FunctionCall__Group__217657 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_rule__FunctionCall__Group__2__Impl17684 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__3__Impl_in_rule__FunctionCall__Group__317713 = new BitSet(new long[]{0x0000000000400000L});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__4_in_rule__FunctionCall__Group__317716 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__FunctionCall__ArgsAssignment_3_in_rule__FunctionCall__Group__3__Impl17743 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__FunctionCall__Group__4__Impl_in_rule__FunctionCall__Group__417773 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_rule__FunctionCall__Group__4__Impl17800 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ThisProperty__Group__0__Impl_in_rule__ThisProperty__Group__017839 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__ThisProperty__Group__1_in_rule__ThisProperty__Group__017842 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_AT_SIGIL_in_rule__ThisProperty__Group__0__Impl17869 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ThisProperty__Group__1__Impl_in_rule__ThisProperty__Group__117898 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__ThisProperty__Group__1__Impl17925 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__Group_0__0__Impl_in_rule__NamedPropertyAccess__Group_0__017958 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__Group_0__1_in_rule__NamedPropertyAccess__Group_0__017961 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__AccessorAssignment_0_0_in_rule__NamedPropertyAccess__Group_0__0__Impl17988 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__Group_0__1__Impl_in_rule__NamedPropertyAccess__Group_0__118018 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__NameAssignment_0_1_in_rule__NamedPropertyAccess__Group_0__1__Impl18045 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__Group_1__0__Impl_in_rule__NamedPropertyAccess__Group_1__018079 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__Group_1__1_in_rule__NamedPropertyAccess__Group_1__018082 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__AccessorAssignment_1_0_in_rule__NamedPropertyAccess__Group_1__0__Impl18109 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__Group_1__1__Impl_in_rule__NamedPropertyAccess__Group_1__118139 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__NameAssignment_1_1_in_rule__NamedPropertyAccess__Group_1__1__Impl18166 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IndexedPropertyAccess__Group__0__Impl_in_rule__IndexedPropertyAccess__Group__018201 = new BitSet(new long[]{0xF9271105B5071F30L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__IndexedPropertyAccess__Group__1_in_rule__IndexedPropertyAccess__Group__018204 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDEX_START_in_rule__IndexedPropertyAccess__Group__0__Impl18231 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IndexedPropertyAccess__Group__1__Impl_in_rule__IndexedPropertyAccess__Group__118260 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_rule__IndexedPropertyAccess__Group__2_in_rule__IndexedPropertyAccess__Group__118263 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IndexedPropertyAccess__IndexAssignment_1_in_rule__IndexedPropertyAccess__Group__1__Impl18290 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IndexedPropertyAccess__Group__2__Impl_in_rule__IndexedPropertyAccess__Group__218320 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDEX_END_in_rule__IndexedPropertyAccess__Group__2__Impl18347 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_0__0__Impl_in_rule__Index__Group_0__018382 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Index__Group_0__1_in_rule__Index__Group_0__018385 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__DotsAssignment_0_0_in_rule__Index__Group_0__0__Impl18412 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_0__1__Impl_in_rule__Index__Group_0__118442 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__EndAssignment_0_1_in_rule__Index__Group_0__1__Impl18469 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_1__0__Impl_in_rule__Index__Group_1__018503 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Index__Group_1__1_in_rule__Index__Group_1__018506 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_1_0__0_in_rule__Index__Group_1__0__Impl18533 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_1__1__Impl_in_rule__Index__Group_1__118563 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__EndAssignment_1_1_in_rule__Index__Group_1__1__Impl18590 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_1_0__0__Impl_in_rule__Index__Group_1_0__018625 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_1_0_0__0_in_rule__Index__Group_1_0__0__Impl18652 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_1_0_0__0__Impl_in_rule__Index__Group_1_0_0__018684 = new BitSet(new long[]{0x0000000000000030L});
+ public static final BitSet FOLLOW_rule__Index__Group_1_0_0__1_in_rule__Index__Group_1_0_0__018687 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__StartAssignment_1_0_0_0_in_rule__Index__Group_1_0_0__0__Impl18714 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_1_0_0__1__Impl_in_rule__Index__Group_1_0_0__118744 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__DotsAssignment_1_0_0_1_in_rule__Index__Group_1_0_0__1__Impl18771 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_8__0__Impl_in_rule__PrimaryExpression__Group_8__018805 = new BitSet(new long[]{0x0001000000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_8__1_in_rule__PrimaryExpression__Group_8__018808 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_8__1__Impl_in_rule__PrimaryExpression__Group_8__118866 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_THIS_in_rule__PrimaryExpression__Group_8__1__Impl18893 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9__0__Impl_in_rule__PrimaryExpression__Group_9__018926 = new BitSet(new long[]{0x0000000080000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9__1_in_rule__PrimaryExpression__Group_9__018929 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9__1__Impl_in_rule__PrimaryExpression__Group_9__118987 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9_1__0_in_rule__PrimaryExpression__Group_9__1__Impl19014 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9_1__0__Impl_in_rule__PrimaryExpression__Group_9_1__019048 = new BitSet(new long[]{0x0000000800000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9_1__1_in_rule__PrimaryExpression__Group_9_1__019051 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOR_in_rule__PrimaryExpression__Group_9_1__0__Impl19078 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9_1__1__Impl_in_rule__PrimaryExpression__Group_9_1__119107 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9_1__2_in_rule__PrimaryExpression__Group_9_1__119110 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__LoopAssignment_9_1_1_in_rule__PrimaryExpression__Group_9_1__1__Impl19137 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_9_1__2__Impl_in_rule__PrimaryExpression__Group_9_1__219167 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__BodyAssignment_9_1_2_in_rule__PrimaryExpression__Group_9_1__2__Impl19194 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10__0__Impl_in_rule__PrimaryExpression__Group_10__019230 = new BitSet(new long[]{0x0000000100000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10__1_in_rule__PrimaryExpression__Group_10__019233 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10__1__Impl_in_rule__PrimaryExpression__Group_10__119291 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1__0_in_rule__PrimaryExpression__Group_10__1__Impl19318 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1__0__Impl_in_rule__PrimaryExpression__Group_10_1__019352 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1__1_in_rule__PrimaryExpression__Group_10_1__019355 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHILE_in_rule__PrimaryExpression__Group_10_1__0__Impl19382 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1__1__Impl_in_rule__PrimaryExpression__Group_10_1__119411 = new BitSet(new long[]{0x0000020200000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1__2_in_rule__PrimaryExpression__Group_10_1__119414 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__LoopAssignment_10_1_1_in_rule__PrimaryExpression__Group_10_1__1__Impl19441 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1__2__Impl_in_rule__PrimaryExpression__Group_10_1__219471 = new BitSet(new long[]{0x0000020200000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1__3_in_rule__PrimaryExpression__Group_10_1__219474 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1_2__0_in_rule__PrimaryExpression__Group_10_1__2__Impl19501 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1__3__Impl_in_rule__PrimaryExpression__Group_10_1__319532 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__BodyAssignment_10_1_3_in_rule__PrimaryExpression__Group_10_1__3__Impl19559 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1_2__0__Impl_in_rule__PrimaryExpression__Group_10_1_2__019597 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1_2__1_in_rule__PrimaryExpression__Group_10_1_2__019600 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rule__PrimaryExpression__Group_10_1_2__0__Impl19627 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_10_1_2__1__Impl_in_rule__PrimaryExpression__Group_10_1_2__119656 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__WhenAssignment_10_1_2_1_in_rule__PrimaryExpression__Group_10_1_2__1__Impl19683 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11__0__Impl_in_rule__PrimaryExpression__Group_11__019717 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11__1_in_rule__PrimaryExpression__Group_11__019720 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11__1__Impl_in_rule__PrimaryExpression__Group_11__119778 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1__0_in_rule__PrimaryExpression__Group_11__1__Impl19805 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1__0__Impl_in_rule__PrimaryExpression__Group_11_1__019839 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1__1_in_rule__PrimaryExpression__Group_11_1__019842 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNTIL_in_rule__PrimaryExpression__Group_11_1__0__Impl19869 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1__1__Impl_in_rule__PrimaryExpression__Group_11_1__119898 = new BitSet(new long[]{0x0000020200000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1__2_in_rule__PrimaryExpression__Group_11_1__119901 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__LoopAssignment_11_1_1_in_rule__PrimaryExpression__Group_11_1__1__Impl19928 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1__2__Impl_in_rule__PrimaryExpression__Group_11_1__219958 = new BitSet(new long[]{0x0000020200000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1__3_in_rule__PrimaryExpression__Group_11_1__219961 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1_2__0_in_rule__PrimaryExpression__Group_11_1__2__Impl19988 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1__3__Impl_in_rule__PrimaryExpression__Group_11_1__320019 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__BodyAssignment_11_1_3_in_rule__PrimaryExpression__Group_11_1__3__Impl20046 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1_2__0__Impl_in_rule__PrimaryExpression__Group_11_1_2__020084 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1_2__1_in_rule__PrimaryExpression__Group_11_1_2__020087 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rule__PrimaryExpression__Group_11_1_2__0__Impl20114 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_11_1_2__1__Impl_in_rule__PrimaryExpression__Group_11_1_2__120143 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__WhenAssignment_11_1_2_1_in_rule__PrimaryExpression__Group_11_1_2__1__Impl20170 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_12__0__Impl_in_rule__PrimaryExpression__Group_12__020204 = new BitSet(new long[]{0x0002000000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_12__1_in_rule__PrimaryExpression__Group_12__020207 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_12__1__Impl_in_rule__PrimaryExpression__Group_12__120265 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_12_1__0_in_rule__PrimaryExpression__Group_12__1__Impl20292 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_12_1__0__Impl_in_rule__PrimaryExpression__Group_12_1__020326 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_12_1__1_in_rule__PrimaryExpression__Group_12_1__020329 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LOOP_in_rule__PrimaryExpression__Group_12_1__0__Impl20356 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_12_1__1__Impl_in_rule__PrimaryExpression__Group_12_1__120385 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__BodyAssignment_12_1_1_in_rule__PrimaryExpression__Group_12_1__1__Impl20412 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13__0__Impl_in_rule__PrimaryExpression__Group_13__020446 = new BitSet(new long[]{0x0004000000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13__1_in_rule__PrimaryExpression__Group_13__020449 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13__1__Impl_in_rule__PrimaryExpression__Group_13__120507 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1__0_in_rule__PrimaryExpression__Group_13__1__Impl20534 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1__0__Impl_in_rule__PrimaryExpression__Group_13_1__020568 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1__1_in_rule__PrimaryExpression__Group_13_1__020571 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TRY_in_rule__PrimaryExpression__Group_13_1__0__Impl20598 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1__1__Impl_in_rule__PrimaryExpression__Group_13_1__120627 = new BitSet(new long[]{0x0018000000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1__2_in_rule__PrimaryExpression__Group_13_1__120630 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__BodyAssignment_13_1_1_in_rule__PrimaryExpression__Group_13_1__1__Impl20657 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1__2__Impl_in_rule__PrimaryExpression__Group_13_1__220687 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Alternatives_13_1_2_in_rule__PrimaryExpression__Group_13_1__2__Impl20714 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__0__Impl_in_rule__PrimaryExpression__Group_13_1_2_0__020751 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__1_in_rule__PrimaryExpression__Group_13_1_2_0__020754 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CATCH_in_rule__PrimaryExpression__Group_13_1_2_0__0__Impl20781 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__1__Impl_in_rule__PrimaryExpression__Group_13_1_2_0__120810 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__2_in_rule__PrimaryExpression__Group_13_1_2_0__120813 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_1_in_rule__PrimaryExpression__Group_13_1_2_0__1__Impl20840 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__2__Impl_in_rule__PrimaryExpression__Group_13_1_2_0__220870 = new BitSet(new long[]{0x0010000000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__3_in_rule__PrimaryExpression__Group_13_1_2_0__220873 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_2_in_rule__PrimaryExpression__Group_13_1_2_0__2__Impl20900 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0__3__Impl_in_rule__PrimaryExpression__Group_13_1_2_0__320930 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0_3__0_in_rule__PrimaryExpression__Group_13_1_2_0__3__Impl20957 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl_in_rule__PrimaryExpression__Group_13_1_2_0_3__020996 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0_3__1_in_rule__PrimaryExpression__Group_13_1_2_0_3__020999 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FINALLY_in_rule__PrimaryExpression__Group_13_1_2_0_3__0__Impl21026 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl_in_rule__PrimaryExpression__Group_13_1_2_0_3__121055 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_1_in_rule__PrimaryExpression__Group_13_1_2_0_3__1__Impl21082 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_1__0__Impl_in_rule__PrimaryExpression__Group_13_1_2_1__021116 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_1__1_in_rule__PrimaryExpression__Group_13_1_2_1__021119 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FINALLY_in_rule__PrimaryExpression__Group_13_1_2_1__0__Impl21146 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_13_1_2_1__1__Impl_in_rule__PrimaryExpression__Group_13_1_2_1__121175 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_1_in_rule__PrimaryExpression__Group_13_1_2_1__1__Impl21202 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14__0__Impl_in_rule__PrimaryExpression__Group_14__021236 = new BitSet(new long[]{0x0020000000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14__1_in_rule__PrimaryExpression__Group_14__021239 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14__1__Impl_in_rule__PrimaryExpression__Group_14__121297 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__0_in_rule__PrimaryExpression__Group_14__1__Impl21324 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__0__Impl_in_rule__PrimaryExpression__Group_14_1__021358 = new BitSet(new long[]{0xF9271305B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__1_in_rule__PrimaryExpression__Group_14_1__021361 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_SWITCH_in_rule__PrimaryExpression__Group_14_1__0__Impl21388 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__1__Impl_in_rule__PrimaryExpression__Group_14_1__121417 = new BitSet(new long[]{0xF9271305B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__2_in_rule__PrimaryExpression__Group_14_1__121420 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__ExpAssignment_14_1_1_in_rule__PrimaryExpression__Group_14_1__1__Impl21447 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__2__Impl_in_rule__PrimaryExpression__Group_14_1__221478 = new BitSet(new long[]{0x00C0040000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__3_in_rule__PrimaryExpression__Group_14_1__221481 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rule__PrimaryExpression__Group_14_1__2__Impl21508 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__3__Impl_in_rule__PrimaryExpression__Group_14_1__321537 = new BitSet(new long[]{0x00C0040000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__4_in_rule__PrimaryExpression__Group_14_1__321540 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__CasesAssignment_14_1_3_in_rule__PrimaryExpression__Group_14_1__3__Impl21567 = new BitSet(new long[]{0x0080000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__4__Impl_in_rule__PrimaryExpression__Group_14_1__421598 = new BitSet(new long[]{0x00C0040000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__5_in_rule__PrimaryExpression__Group_14_1__421601 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1_4__0_in_rule__PrimaryExpression__Group_14_1__4__Impl21628 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1__5__Impl_in_rule__PrimaryExpression__Group_14_1__521659 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rule__PrimaryExpression__Group_14_1__5__Impl21686 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1_4__0__Impl_in_rule__PrimaryExpression__Group_14_1_4__021727 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1_4__1_in_rule__PrimaryExpression__Group_14_1_4__021730 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELSE_in_rule__PrimaryExpression__Group_14_1_4__0__Impl21757 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__Group_14_1_4__1__Impl_in_rule__PrimaryExpression__Group_14_1_4__121786 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__PrimaryExpression__ElseBlockAssignment_14_1_4_1_in_rule__PrimaryExpression__Group_14_1_4__1__Impl21813 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Block__Group__0__Impl_in_rule__Block__Group__021847 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__Block__Group__1_in_rule__Block__Group__021850 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Block__Group__1__Impl_in_rule__Block__Group__121908 = new BitSet(new long[]{0xF9271505B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Block__Group__2_in_rule__Block__Group__121911 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rule__Block__Group__1__Impl21938 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Block__Group__2__Impl_in_rule__Block__Group__221967 = new BitSet(new long[]{0xF9271505B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Block__Group__3_in_rule__Block__Group__221970 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBody_in_rule__Block__Group__2__Impl21998 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Block__Group__3__Impl_in_rule__Block__Group__322029 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rule__Block__Group__3__Impl22056 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__Group__0__Impl_in_rule__Case__Group__022093 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Case__Group__1_in_rule__Case__Group__022096 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LEADING_WHEN_in_rule__Case__Group__0__Impl22123 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__Group__1__Impl_in_rule__Case__Group__122152 = new BitSet(new long[]{0x0000020000200000L});
+ public static final BitSet FOLLOW_rule__Case__Group__2_in_rule__Case__Group__122155 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__WhensAssignment_1_in_rule__Case__Group__1__Impl22182 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__Group__2__Impl_in_rule__Case__Group__222212 = new BitSet(new long[]{0x0000020000200000L});
+ public static final BitSet FOLLOW_rule__Case__Group__3_in_rule__Case__Group__222215 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__Group_2__0_in_rule__Case__Group__2__Impl22242 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_rule__Case__Group__3__Impl_in_rule__Case__Group__322273 = new BitSet(new long[]{0x0000000000800000L});
+ public static final BitSet FOLLOW_rule__Case__Group__4_in_rule__Case__Group__322276 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__ThenAssignment_3_in_rule__Case__Group__3__Impl22303 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__Group__4__Impl_in_rule__Case__Group__422333 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_rule__Case__Group__4__Impl22361 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__Group_2__0__Impl_in_rule__Case__Group_2__022402 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Case__Group_2__1_in_rule__Case__Group_2__022405 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__Case__Group_2__0__Impl22432 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__Group_2__1__Impl_in_rule__Case__Group_2__122461 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Case__WhensAssignment_2_1_in_rule__Case__Group_2__1__Impl22488 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group__0__Impl_in_rule__IfExp__Group__022522 = new BitSet(new long[]{0x0040000000000000L});
+ public static final BitSet FOLLOW_rule__IfExp__Group__1_in_rule__IfExp__Group__022525 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__BlocksAssignment_0_in_rule__IfExp__Group__0__Impl22552 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group__1__Impl_in_rule__IfExp__Group__122582 = new BitSet(new long[]{0x0040000000000000L});
+ public static final BitSet FOLLOW_rule__IfExp__Group__2_in_rule__IfExp__Group__122585 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group_1__0_in_rule__IfExp__Group__1__Impl22612 = new BitSet(new long[]{0x0040000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group__2__Impl_in_rule__IfExp__Group__222643 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group_2__0_in_rule__IfExp__Group__2__Impl22670 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group_1__0__Impl_in_rule__IfExp__Group_1__022707 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
+ public static final BitSet FOLLOW_rule__IfExp__Group_1__1_in_rule__IfExp__Group_1__022710 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELSE_in_rule__IfExp__Group_1__0__Impl22737 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group_1__1__Impl_in_rule__IfExp__Group_1__122766 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__BlocksAssignment_1_1_in_rule__IfExp__Group_1__1__Impl22793 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group_2__0__Impl_in_rule__IfExp__Group_2__022827 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__IfExp__Group_2__1_in_rule__IfExp__Group_2__022830 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELSE_in_rule__IfExp__Group_2__0__Impl22857 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__Group_2__1__Impl_in_rule__IfExp__Group_2__122886 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__IfExp__DefaultBlockAssignment_2_1_in_rule__IfExp__Group_2__1__Impl22913 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CondBlock__Group__0__Impl_in_rule__CondBlock__Group__022947 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__CondBlock__Group__1_in_rule__CondBlock__Group__022950 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CondBlock__OperatorAssignment_0_in_rule__CondBlock__Group__0__Impl22977 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CondBlock__Group__1__Impl_in_rule__CondBlock__Group__123007 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__CondBlock__Group__2_in_rule__CondBlock__Group__123010 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CondBlock__ConditionAssignment_1_in_rule__CondBlock__Group__1__Impl23037 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CondBlock__Group__2__Impl_in_rule__CondBlock__Group__223067 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CondBlock__ActionAssignment_2_in_rule__CondBlock__Group__2__Impl23094 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_0__0__Impl_in_rule__Property__Group_0__023130 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__Property__Group_0__1_in_rule__Property__Group_0__023133 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_0_0__0_in_rule__Property__Group_0__0__Impl23160 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_0__1__Impl_in_rule__Property__Group_0__123190 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__PropAssignment_0_1_in_rule__Property__Group_0__1__Impl23217 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_0_0__0__Impl_in_rule__Property__Group_0_0__023251 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_0_0_0__0_in_rule__Property__Group_0_0__0__Impl23278 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_0_0_0__0__Impl_in_rule__Property__Group_0_0_0__023310 = new BitSet(new long[]{0x000000000000E000L});
+ public static final BitSet FOLLOW_rule__Property__Group_0_0_0__1_in_rule__Property__Group_0_0_0__023313 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_rule__Property__Group_0_0_0__0__Impl23340 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_0_0_0__1__Impl_in_rule__Property__Group_0_0_0__123369 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__AccessorAssignment_0_0_0_1_in_rule__Property__Group_0_0_0__1__Impl23396 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_1__0__Impl_in_rule__Property__Group_1__023430 = new BitSet(new long[]{0xF9271105B5071F30L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Property__Group_1__1_in_rule__Property__Group_1__023433 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_1_0__0_in_rule__Property__Group_1__0__Impl23460 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_1__1__Impl_in_rule__Property__Group_1__123490 = new BitSet(new long[]{0x0000800000000000L});
+ public static final BitSet FOLLOW_rule__Property__Group_1__2_in_rule__Property__Group_1__123493 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__IndexAssignment_1_1_in_rule__Property__Group_1__1__Impl23520 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_1__2__Impl_in_rule__Property__Group_1__223550 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDEX_END_in_rule__Property__Group_1__2__Impl23577 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_1_0__0__Impl_in_rule__Property__Group_1_0__023612 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_1_0_0__0_in_rule__Property__Group_1_0__0__Impl23639 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_1_0_0__0__Impl_in_rule__Property__Group_1_0_0__023671 = new BitSet(new long[]{0x0000400000000000L});
+ public static final BitSet FOLLOW_rule__Property__Group_1_0_0__1_in_rule__Property__Group_1_0_0__023674 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_rule__Property__Group_1_0_0__0__Impl23701 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__Group_1_0_0__1__Impl_in_rule__Property__Group_1_0_0__123730 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDEX_START_in_rule__Property__Group_1_0_0__1__Impl23757 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1__0__Impl_in_rule__Variable__Group_1__023790 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1__1_in_rule__Variable__Group_1__023793 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Alternatives_1_0_in_rule__Variable__Group_1__0__Impl23820 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1__1__Impl_in_rule__Variable__Group_1__123850 = new BitSet(new long[]{0x0000000000002000L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1__2_in_rule__Variable__Group_1__123853 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__Variable__Group_1__1__Impl23880 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1__2__Impl_in_rule__Variable__Group_1__223909 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1_2__0_in_rule__Variable__Group_1__2__Impl23936 = new BitSet(new long[]{0x0000000000002002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1_0_1__0__Impl_in_rule__Variable__Group_1_0_1__023973 = new BitSet(new long[]{0x0000000000002000L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1_0_1__1_in_rule__Variable__Group_1_0_1__023976 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_THIS_in_rule__Variable__Group_1_0_1__0__Impl24003 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1_0_1__1__Impl_in_rule__Variable__Group_1_0_1__124032 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_in_rule__Variable__Group_1_0_1__1__Impl24059 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1_2__0__Impl_in_rule__Variable__Group_1_2__024092 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1_2__1_in_rule__Variable__Group_1_2__024095 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_in_rule__Variable__Group_1_2__0__Impl24122 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__Group_1_2__1__Impl_in_rule__Variable__Group_1_2__124151 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Variable__PropsAssignment_1_2_1_in_rule__Variable__Group_1_2__1__Impl24178 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArray__Group__0__Impl_in_rule__AssignableArray__Group__024212 = new BitSet(new long[]{0x0101010000010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__AssignableArray__Group__1_in_rule__AssignableArray__Group__024215 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_rule__AssignableArray__Group__0__Impl24243 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArray__Group__1__Impl_in_rule__AssignableArray__Group__124273 = new BitSet(new long[]{0x0000008000000000L});
+ public static final BitSet FOLLOW_rule__AssignableArray__Group__2_in_rule__AssignableArray__Group__124276 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArgList_in_rule__AssignableArray__Group__1__Impl24303 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArray__Group__2__Impl_in_rule__AssignableArray__Group__224332 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RBRACKET_in_rule__AssignableArray__Group__2__Impl24359 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__Group__0__Impl_in_rule__AssignableArgList__Group__024394 = new BitSet(new long[]{0x0000000000200000L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__Group__1_in_rule__AssignableArgList__Group__024397 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__ArgsAssignment_0_in_rule__AssignableArgList__Group__0__Impl24424 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__Group__1__Impl_in_rule__AssignableArgList__Group__124454 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__Group_1__0_in_rule__AssignableArgList__Group__1__Impl24481 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__Group_1__0__Impl_in_rule__AssignableArgList__Group_1__024516 = new BitSet(new long[]{0x0101010000010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__Group_1__1_in_rule__AssignableArgList__Group_1__024519 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__AssignableArgList__Group_1__0__Impl24546 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__Group_1__1__Impl_in_rule__AssignableArgList__Group_1__124575 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArgList__ArgsAssignment_1_1_in_rule__AssignableArgList__Group_1__1__Impl24602 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArg__Group__0__Impl_in_rule__AssignableArg__Group__024636 = new BitSet(new long[]{0x0000000000000020L});
+ public static final BitSet FOLLOW_rule__AssignableArg__Group__1_in_rule__AssignableArg__Group__024639 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArg__ArgAssignment_0_in_rule__AssignableArg__Group__0__Impl24666 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArg__Group__1__Impl_in_rule__AssignableArg__Group__124696 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignableArg__SplatAssignment_1_in_rule__AssignableArg__Group__1__Impl24723 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Arg__Group__0__Impl_in_rule__Arg__Group__024758 = new BitSet(new long[]{0x0000000000000020L});
+ public static final BitSet FOLLOW_rule__Arg__Group__1_in_rule__Arg__Group__024761 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Arg__ExpAssignment_0_in_rule__Arg__Group__0__Impl24788 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Arg__Group__1__Impl_in_rule__Arg__Group__124818 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Arg__SplatAssignment_1_in_rule__Arg__Group__1__Impl24845 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgLine__Group__0__Impl_in_rule__ArgLine__Group__024880 = new BitSet(new long[]{0x0000000000200000L});
+ public static final BitSet FOLLOW_rule__ArgLine__Group__1_in_rule__ArgLine__Group__024883 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgLine__HeadAssignment_0_in_rule__ArgLine__Group__0__Impl24910 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgLine__Group__1__Impl_in_rule__ArgLine__Group__124940 = new BitSet(new long[]{0x0000000000200000L});
+ public static final BitSet FOLLOW_rule__ArgLine__Group__2_in_rule__ArgLine__Group__124943 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgLine__Group_1__0_in_rule__ArgLine__Group__1__Impl24970 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_rule__ArgLine__Group__2__Impl_in_rule__ArgLine__Group__225001 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__ArgLine__Group__2__Impl25029 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgLine__Group_1__0__Impl_in_rule__ArgLine__Group_1__025066 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ArgLine__Group_1__1_in_rule__ArgLine__Group_1__025069 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__ArgLine__Group_1__0__Impl25096 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgLine__Group_1__1__Impl_in_rule__ArgLine__Group_1__125125 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgLine__TailAssignment_1_1_in_rule__ArgLine__Group_1__1__Impl25152 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group__0__Impl_in_rule__ExplicitArgList__Group__025186 = new BitSet(new long[]{0x0000020000800000L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group__1_in_rule__ExplicitArgList__Group__025189 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__LinesAssignment_0_in_rule__ExplicitArgList__Group__0__Impl25216 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group__1__Impl_in_rule__ExplicitArgList__Group__125246 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Alternatives_1_in_rule__ExplicitArgList__Group__1__Impl25273 = new BitSet(new long[]{0x0000020000800002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_0__0__Impl_in_rule__ExplicitArgList__Group_1_0__025308 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_0__1_in_rule__ExplicitArgList__Group_1_0__025311 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_rule__ExplicitArgList__Group_1_0__0__Impl25338 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_0__1__Impl_in_rule__ExplicitArgList__Group_1_0__125367 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__LinesAssignment_1_0_1_in_rule__ExplicitArgList__Group_1_0__1__Impl25394 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_1__0__Impl_in_rule__ExplicitArgList__Group_1_1__025428 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_1__1_in_rule__ExplicitArgList__Group_1_1__025431 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rule__ExplicitArgList__Group_1_1__0__Impl25458 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_1__1__Impl_in_rule__ExplicitArgList__Group_1_1__125487 = new BitSet(new long[]{0x0000040000000000L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_1__2_in_rule__ExplicitArgList__Group_1_1__125490 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__LinesAssignment_1_1_1_in_rule__ExplicitArgList__Group_1_1__1__Impl25517 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitArgList__Group_1_1__2__Impl_in_rule__ExplicitArgList__Group_1_1__225547 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rule__ExplicitArgList__Group_1_1__2__Impl25574 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__Group__0__Impl_in_rule__ArgList__Group__025609 = new BitSet(new long[]{0xF9271305B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ArgList__Group__1_in_rule__ArgList__Group__025612 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__Group__1__Impl_in_rule__ArgList__Group__125670 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__Alternatives_1_in_rule__ArgList__Group__1__Impl25697 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__Group_1_1__0__Impl_in_rule__ArgList__Group_1_1__025732 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__ArgList__Group_1_1__1_in_rule__ArgList__Group_1_1__025735 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rule__ArgList__Group_1_1__0__Impl25762 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__Group_1_1__1__Impl_in_rule__ArgList__Group_1_1__125791 = new BitSet(new long[]{0x0000040000000000L});
+ public static final BitSet FOLLOW_rule__ArgList__Group_1_1__2_in_rule__ArgList__Group_1_1__125794 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__DummyAssignment_1_1_1_in_rule__ArgList__Group_1_1__1__Impl25821 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ArgList__Group_1_1__2__Impl_in_rule__ArgList__Group_1_1__225851 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rule__ArgList__Group_1_1__2__Impl25878 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Array__Group__0__Impl_in_rule__Array__Group__025913 = new BitSet(new long[]{0xF9271305B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Array__Group__1_in_rule__Array__Group__025916 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_rule__Array__Group__0__Impl25944 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Array__Group__1__Impl_in_rule__Array__Group__125974 = new BitSet(new long[]{0x0000008000000000L});
+ public static final BitSet FOLLOW_rule__Array__Group__2_in_rule__Array__Group__125977 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgList_in_rule__Array__Group__1__Impl26004 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Array__Group__2__Impl_in_rule__Array__Group__226033 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RBRACKET_in_rule__Array__Group__2__Impl26060 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Dictionary__Group__0__Impl_in_rule__Dictionary__Group__026095 = new BitSet(new long[]{0xF800020000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__Dictionary__Group__1_in_rule__Dictionary__Group__026098 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LCURLY_in_rule__Dictionary__Group__0__Impl26126 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Dictionary__Group__1__Impl_in_rule__Dictionary__Group__126156 = new BitSet(new long[]{0x0200000000000000L});
+ public static final BitSet FOLLOW_rule__Dictionary__Group__2_in_rule__Dictionary__Group__126159 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItems_in_rule__Dictionary__Group__1__Impl26186 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Dictionary__Group__2__Impl_in_rule__Dictionary__Group__226215 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RCURLY_in_rule__Dictionary__Group__2__Impl26242 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__Group__0__Impl_in_rule__DictItems__Group__026277 = new BitSet(new long[]{0xF800020000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__DictItems__Group__1_in_rule__DictItems__Group__026280 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__Group__1__Impl_in_rule__DictItems__Group__126338 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__Alternatives_1_in_rule__DictItems__Group__1__Impl26365 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__Group_1_1__0__Impl_in_rule__DictItems__Group_1_1__026400 = new BitSet(new long[]{0xF800000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__DictItems__Group_1_1__1_in_rule__DictItems__Group_1_1__026403 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rule__DictItems__Group_1_1__0__Impl26430 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__Group_1_1__1__Impl_in_rule__DictItems__Group_1_1__126459 = new BitSet(new long[]{0x0000040000000000L});
+ public static final BitSet FOLLOW_rule__DictItems__Group_1_1__2_in_rule__DictItems__Group_1_1__126462 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__DummyAssignment_1_1_1_in_rule__DictItems__Group_1_1__1__Impl26489 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItems__Group_1_1__2__Impl_in_rule__DictItems__Group_1_1__226519 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rule__DictItems__Group_1_1__2__Impl26546 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group__0__Impl_in_rule__ExplicitDictItems__Group__026581 = new BitSet(new long[]{0x0000020000800000L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group__1_in_rule__ExplicitDictItems__Group__026584 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__LinesAssignment_0_in_rule__ExplicitDictItems__Group__0__Impl26611 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group__1__Impl_in_rule__ExplicitDictItems__Group__126641 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Alternatives_1_in_rule__ExplicitDictItems__Group__1__Impl26668 = new BitSet(new long[]{0x0000020000800002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_0__0__Impl_in_rule__ExplicitDictItems__Group_1_0__026703 = new BitSet(new long[]{0xF800000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_0__1_in_rule__ExplicitDictItems__Group_1_0__026706 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_rule__ExplicitDictItems__Group_1_0__0__Impl26733 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_0__1__Impl_in_rule__ExplicitDictItems__Group_1_0__126762 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__LinesAssignment_1_0_1_in_rule__ExplicitDictItems__Group_1_0__1__Impl26789 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_1__0__Impl_in_rule__ExplicitDictItems__Group_1_1__026823 = new BitSet(new long[]{0xF800000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_1__1_in_rule__ExplicitDictItems__Group_1_1__026826 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rule__ExplicitDictItems__Group_1_1__0__Impl26853 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_1__1__Impl_in_rule__ExplicitDictItems__Group_1_1__126882 = new BitSet(new long[]{0x0000040000000000L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_1__2_in_rule__ExplicitDictItems__Group_1_1__126885 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__LinesAssignment_1_1_1_in_rule__ExplicitDictItems__Group_1_1__1__Impl26912 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ExplicitDictItems__Group_1_1__2__Impl_in_rule__ExplicitDictItems__Group_1_1__226942 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rule__ExplicitDictItems__Group_1_1__2__Impl26969 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictLine__Group__0__Impl_in_rule__DictLine__Group__027004 = new BitSet(new long[]{0x0000000000200000L});
+ public static final BitSet FOLLOW_rule__DictLine__Group__1_in_rule__DictLine__Group__027007 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictLine__HeadAssignment_0_in_rule__DictLine__Group__0__Impl27034 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictLine__Group__1__Impl_in_rule__DictLine__Group__127064 = new BitSet(new long[]{0x0000000000200000L});
+ public static final BitSet FOLLOW_rule__DictLine__Group__2_in_rule__DictLine__Group__127067 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictLine__Group_1__0_in_rule__DictLine__Group__1__Impl27094 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_rule__DictLine__Group__2__Impl_in_rule__DictLine__Group__227125 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__DictLine__Group__2__Impl27153 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictLine__Group_1__0__Impl_in_rule__DictLine__Group_1__027190 = new BitSet(new long[]{0xF800000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__DictLine__Group_1__1_in_rule__DictLine__Group_1__027193 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__DictLine__Group_1__0__Impl27220 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictLine__Group_1__1__Impl_in_rule__DictLine__Group_1__127249 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictLine__TailAssignment_1_1_in_rule__DictLine__Group_1__1__Impl27276 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group__0__Impl_in_rule__DictItem__Group__027310 = new BitSet(new long[]{0xF800000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__DictItem__Group__1_in_rule__DictItem__Group__027313 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group__1__Impl_in_rule__DictItem__Group__127371 = new BitSet(new long[]{0x0400000000000000L});
+ public static final BitSet FOLLOW_rule__DictItem__Group__2_in_rule__DictItem__Group__127374 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__KeyAssignment_1_in_rule__DictItem__Group__1__Impl27401 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group__2__Impl_in_rule__DictItem__Group__227431 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2__0_in_rule__DictItem__Group__2__Impl27458 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2__0__Impl_in_rule__DictItem__Group_2__027495 = new BitSet(new long[]{0xF9271305B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2__1_in_rule__DictItem__Group_2__027498 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COLON_in_rule__DictItem__Group_2__0__Impl27525 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2__1__Impl_in_rule__DictItem__Group_2__127554 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Alternatives_2_1_in_rule__DictItem__Group_2__1__Impl27581 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2_1_1__0__Impl_in_rule__DictItem__Group_2_1_1__027615 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2_1_1__1_in_rule__DictItem__Group_2_1_1__027618 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rule__DictItem__Group_2_1_1__0__Impl27645 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2_1_1__1__Impl_in_rule__DictItem__Group_2_1_1__127674 = new BitSet(new long[]{0x0000040000000000L});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2_1_1__2_in_rule__DictItem__Group_2_1_1__127677 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__ValueAssignment_2_1_1_1_in_rule__DictItem__Group_2_1_1__1__Impl27704 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__DictItem__Group_2_1_1__2__Impl_in_rule__DictItem__Group_2_1_1__227734 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rule__DictItem__Group_2_1_1__2__Impl27761 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group__0__Impl_in_rule__Lambda__Group__027796 = new BitSet(new long[]{0x0000000001060000L});
+ public static final BitSet FOLLOW_rule__Lambda__Group__1_in_rule__Lambda__Group__027799 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0__0_in_rule__Lambda__Group__0__Impl27826 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group__1__Impl_in_rule__Lambda__Group__127857 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__Lambda__Group__2_in_rule__Lambda__Group__127860 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Alternatives_1_in_rule__Lambda__Group__1__Impl27887 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group__2__Impl_in_rule__Lambda__Group__227917 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__BodyAssignment_2_in_rule__Lambda__Group__2__Impl27944 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0__0__Impl_in_rule__Lambda__Group_0__027980 = new BitSet(new long[]{0x0100010002010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0__1_in_rule__Lambda__Group_0__027983 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PARAM_START_in_rule__Lambda__Group_0__0__Impl28010 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0__1__Impl_in_rule__Lambda__Group_0__128039 = new BitSet(new long[]{0x0100010002010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0__2_in_rule__Lambda__Group_0__128042 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0_1__0_in_rule__Lambda__Group_0__1__Impl28069 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0__2__Impl_in_rule__Lambda__Group_0__228100 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PARAM_END_in_rule__Lambda__Group_0__2__Impl28127 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0_1__0__Impl_in_rule__Lambda__Group_0_1__028162 = new BitSet(new long[]{0x0000000000200000L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0_1__1_in_rule__Lambda__Group_0_1__028165 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__ParamsAssignment_0_1_0_in_rule__Lambda__Group_0_1__0__Impl28192 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0_1__1__Impl_in_rule__Lambda__Group_0_1__128222 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0_1_1__0_in_rule__Lambda__Group_0_1__1__Impl28249 = new BitSet(new long[]{0x0000000000200002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0_1_1__0__Impl_in_rule__Lambda__Group_0_1_1__028284 = new BitSet(new long[]{0x0100010000010000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0_1_1__1_in_rule__Lambda__Group_0_1_1__028287 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_rule__Lambda__Group_0_1_1__0__Impl28314 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__Group_0_1_1__1__Impl_in_rule__Lambda__Group_0_1_1__128343 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Lambda__ParamsAssignment_0_1_1_1_in_rule__Lambda__Group_0_1_1__1__Impl28370 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__Group__0__Impl_in_rule__Param__Group__028404 = new BitSet(new long[]{0x0000000000000060L});
+ public static final BitSet FOLLOW_rule__Param__Group__1_in_rule__Param__Group__028407 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__Alternatives_0_in_rule__Param__Group__0__Impl28434 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__Group__1__Impl_in_rule__Param__Group__128464 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__Alternatives_1_in_rule__Param__Group__1__Impl28491 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__Group_1_1__0__Impl_in_rule__Param__Group_1_1__028526 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Param__Group_1_1__1_in_rule__Param__Group_1_1__028529 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_rule__Param__Group_1_1__0__Impl28556 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__Group_1_1__1__Impl_in_rule__Param__Group_1_1__128585 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Param__DefaultValueAssignment_1_1_1_in_rule__Param__Group_1_1__1__Impl28612 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NumberLiteral__Group__0__Impl_in_rule__NumberLiteral__Group__028646 = new BitSet(new long[]{0x0800000000000000L});
+ public static final BitSet FOLLOW_rule__NumberLiteral__Group__1_in_rule__NumberLiteral__Group__028649 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NumberLiteral__Group__1__Impl_in_rule__NumberLiteral__Group__128707 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_NUMBER_in_rule__NumberLiteral__Group__1__Impl28734 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__StringLiteral__Group__0__Impl_in_rule__StringLiteral__Group__028767 = new BitSet(new long[]{0x1000000000000000L});
+ public static final BitSet FOLLOW_rule__StringLiteral__Group__1_in_rule__StringLiteral__Group__028770 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__StringLiteral__Group__1__Impl_in_rule__StringLiteral__Group__128828 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_STRING_in_rule__StringLiteral__Group__1__Impl28855 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__BoolLiteral__Group__0__Impl_in_rule__BoolLiteral__Group__028888 = new BitSet(new long[]{0x2000000000000000L});
+ public static final BitSet FOLLOW_rule__BoolLiteral__Group__1_in_rule__BoolLiteral__Group__028891 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__BoolLiteral__Group__1__Impl_in_rule__BoolLiteral__Group__128949 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BOOL_in_rule__BoolLiteral__Group__1__Impl28976 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__JSLiteral__Group__0__Impl_in_rule__JSLiteral__Group__029009 = new BitSet(new long[]{0x4000000000000000L});
+ public static final BitSet FOLLOW_rule__JSLiteral__Group__1_in_rule__JSLiteral__Group__029012 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__JSLiteral__Group__1__Impl_in_rule__JSLiteral__Group__129070 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_JS_in_rule__JSLiteral__Group__1__Impl29097 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RegexLiteral__Group__0__Impl_in_rule__RegexLiteral__Group__029130 = new BitSet(new long[]{0xF800000000000000L});
+ public static final BitSet FOLLOW_rule__RegexLiteral__Group__1_in_rule__RegexLiteral__Group__029133 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RegexLiteral__Group__1__Impl_in_rule__RegexLiteral__Group__129191 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_REGEX_in_rule__RegexLiteral__Group__1__Impl29218 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0__0__Impl_in_rule__Parenthetical__Group_0__029251 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0__1_in_rule__Parenthetical__Group_0__029254 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0_0__0_in_rule__Parenthetical__Group_0__0__Impl29281 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0__1__Impl_in_rule__Parenthetical__Group_0__129311 = new BitSet(new long[]{0x0000040000000000L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0__2_in_rule__Parenthetical__Group_0__129314 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__ContentAssignment_0_1_in_rule__Parenthetical__Group_0__1__Impl29341 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0__2__Impl_in_rule__Parenthetical__Group_0__229371 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0__3_in_rule__Parenthetical__Group_0__229374 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rule__Parenthetical__Group_0__2__Impl29401 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0__3__Impl_in_rule__Parenthetical__Group_0__329430 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RPAREN_in_rule__Parenthetical__Group_0__3__Impl29457 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0_0__0__Impl_in_rule__Parenthetical__Group_0_0__029494 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0_0_0__0_in_rule__Parenthetical__Group_0_0__0__Impl29521 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0_0_0__0__Impl_in_rule__Parenthetical__Group_0_0_0__029553 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0_0_0__1_in_rule__Parenthetical__Group_0_0_0__029556 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_rule__Parenthetical__Group_0_0_0__0__Impl29583 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_0_0_0__1__Impl_in_rule__Parenthetical__Group_0_0_0__129612 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rule__Parenthetical__Group_0_0_0__1__Impl29639 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_1__0__Impl_in_rule__Parenthetical__Group_1__029672 = new BitSet(new long[]{0xF9271105B5071F00L,0x000000000000060EL});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_1__1_in_rule__Parenthetical__Group_1__029675 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_rule__Parenthetical__Group_1__0__Impl29703 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_1__1__Impl_in_rule__Parenthetical__Group_1__129733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_1__2_in_rule__Parenthetical__Group_1__129736 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__ContentAssignment_1_1_in_rule__Parenthetical__Group_1__1__Impl29763 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Parenthetical__Group_1__2__Impl_in_rule__Parenthetical__Group_1__229793 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RPAREN_in_rule__Parenthetical__Group_1__2__Impl29820 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleTaskDeclaration_in_rule__Cakefile__TasksAssignment29860 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_rule__TaskDeclaration__NameAssignment_229891 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_rule__TaskDeclaration__DescriptionAssignment_429922 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__TaskDeclaration__OptionsAssignment_6_129953 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__TaskDeclaration__BodyAssignment_829984 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLine_in_rule__Body__LinesAssignment_030015 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLine_in_rule__Body__LinesAssignment_1_130046 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_STATEMENT_in_rule__Stmt__StatementAssignment_530077 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_HERECOMMENT_in_rule__Comment__CommentAssignment30108 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__RequireStmt__ImportedNamespaceAssignment_0_0_030139 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_STRING_in_rule__RequireStmt__UriAssignment_230170 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ReturnStmt__ExpressionAssignment_230201 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ReturnStmt__ConditionAssignment_3_130232 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ThrowStmt__ExpAssignment_130263 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__ClassDeclaration__BodyAssignment_2_030294 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_rule__ClassDeclaration__ExtendAssignment_2_1_130325 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__ClassDeclaration__BodyAssignment_2_1_230356 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ClassDeclaration__NameAlternatives_2_2_0_0_in_rule__ClassDeclaration__NameAssignment_2_2_030387 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_rule__ClassDeclaration__ExtendAssignment_2_2_1_130420 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__ClassDeclaration__BodyAssignment_2_2_230451 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_rule__AssignedClassDeclaration__ExtendAssignment_2_0_130482 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__AssignedClassDeclaration__BodyAssignment_2_0_230513 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AssignedClassDeclaration__NameAlternatives_2_1_0_0_in_rule__AssignedClassDeclaration__NameAssignment_2_1_030544 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_rule__AssignedClassDeclaration__ExtendAssignment_2_1_1_130577 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__AssignedClassDeclaration__BodyAssignment_2_1_230608 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Postfix__ConditionAssignment_1_0_230639 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForBody_in_rule__Postfix__BodyAssignment_1_1_230670 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Postfix__BodyAssignment_1_2_230701 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Postfix__WhenAssignment_1_2_3_130732 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Postfix__BodyAssignment_1_3_230763 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Postfix__WhenAssignment_1_3_3_130794 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForValue_in_rule__ForBody__IndexesAssignment_130825 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForValue_in_rule__ForBody__IndexesAssignment_2_130856 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForSource_in_rule__ForBody__SourceAssignment_330887 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ForSource__SourceAssignment_1_0_130918 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ForSource__WhenAssignment_1_0_2_130949 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ForSource__SourceAssignment_1_1_130980 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ForSource__WhenAssignment_1_1_2_0_131011 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ForSource__ByAssignment_1_1_2_0_2_131042 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ForSource__ByAssignment_1_1_2_1_131073 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__ForSource__WhenAssignment_1_1_2_1_2_131104 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Range__StartAssignment_0_0_131135 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Range__EndAssignment_131166 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_rule__Assignment__LeftAssignment_0_0_0_031197 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__OperatorAlternatives_0_0_0_1_0_in_rule__Assignment__OperatorAssignment_0_0_0_131228 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssigned_in_rule__Assignment__RightAssignment_0_131261 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LOGIC_in_rule__LogicOp__OperatorAssignment_1_0_0_131292 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCompareOp_in_rule__LogicOp__RightAssignment_1_131323 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMPARE_in_rule__CompareOp__OperatorAssignment_1_0_0_131354 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRelationOp_in_rule__CompareOp__RightAssignment_1_131385 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RELATION_in_rule__RelationOp__OperatorAssignment_1_0_0_131416 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleShiftOp_in_rule__RelationOp__RightAssignment_1_131447 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_SHIFT_in_rule__ShiftOp__OperatorAssignment_1_0_0_131478 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAdditiveOp_in_rule__ShiftOp__RightAssignment_1_131509 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__OperatorAlternatives_1_0_0_1_0_in_rule__AdditiveOp__OperatorAssignment_1_0_0_131540 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleMathOp_in_rule__AdditiveOp__RightAssignment_1_131573 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_MATH_in_rule__MathOp__OperatorAssignment_1_0_0_131604 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleUnaryOp_in_rule__MathOp__RightAssignment_1_131635 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgList_in_rule__Application__ArgsAssignment_0_1_1_131666 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePrimaryExpression_in_rule__Application__ValueAssignment_1_031697 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleFeatureCall_in_rule__Application__FeaturesAssignment_1_131728 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgList_in_rule__FunctionCall__ArgsAssignment_331759 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__NamedPropertyAccess__AccessorAlternatives_0_0_0_in_rule__NamedPropertyAccess__AccessorAssignment_0_031790 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__NamedPropertyAccess__NameAssignment_0_131823 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOUBLE_COLON_in_rule__NamedPropertyAccess__AccessorAssignment_1_031854 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__NamedPropertyAccess__NameAssignment_1_131885 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndex_in_rule__IndexedPropertyAccess__IndexAssignment_131916 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__DotsAlternatives_0_0_0_in_rule__Index__DotsAssignment_0_031947 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Index__EndAssignment_0_131980 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Index__StartAssignment_1_0_0_032011 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__DotsAlternatives_1_0_0_1_0_in_rule__Index__DotsAssignment_1_0_0_132042 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Index__EndAssignment_1_132075 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Index__ExpAssignment_232106 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForBody_in_rule__PrimaryExpression__LoopAssignment_9_1_132137 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_9_1_232168 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__PrimaryExpression__LoopAssignment_10_1_132199 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__PrimaryExpression__WhenAssignment_10_1_2_132230 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_10_1_332261 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__PrimaryExpression__LoopAssignment_11_1_132292 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__PrimaryExpression__WhenAssignment_11_1_2_132323 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_11_1_332354 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_12_1_132385 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__PrimaryExpression__BodyAssignment_13_1_132416 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__PrimaryExpression__ExceptionAssignment_13_1_2_0_132447 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__PrimaryExpression__CatchBlockAssignment_13_1_2_0_232478 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_0_3_132509 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__PrimaryExpression__FinallyBlockAssignment_13_1_2_1_132540 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__PrimaryExpression__ExpAssignment_14_1_132571 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCase_in_rule__PrimaryExpression__CasesAssignment_14_1_332602 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__PrimaryExpression__ElseBlockAssignment_14_1_4_132633 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Case__WhensAssignment_132664 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Case__WhensAssignment_2_132695 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__Case__ThenAssignment_332726 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCondBlock_in_rule__IfExp__BlocksAssignment_032757 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCondBlock_in_rule__IfExp__BlocksAssignment_1_132788 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__IfExp__DefaultBlockAssignment_2_132819 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_IF_in_rule__CondBlock__OperatorAssignment_032850 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__CondBlock__ConditionAssignment_132881 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__CondBlock__ActionAssignment_232912 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_IDENTIFIER_in_rule__IdRef__ValAssignment32947 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_IDENTIFIER_in_rule__Id__NameAssignment32982 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Property__AccessorAlternatives_0_0_0_1_0_in_rule__Property__AccessorAssignment_0_0_0_133013 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__Property__PropAssignment_0_133046 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndex_in_rule__Property__IndexAssignment_1_133077 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_rule__Variable__PropsAssignment_1_2_133108 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArg_in_rule__AssignableArgList__ArgsAssignment_033139 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArg_in_rule__AssignableArgList__ArgsAssignment_1_133170 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_rule__AssignableArg__ArgAssignment_033201 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_rule__AssignableArg__SplatAssignment_133232 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Arg__ExpAssignment_033263 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_rule__Arg__SplatAssignment_133294 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArg_in_rule__ArgLine__HeadAssignment_033325 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArg_in_rule__ArgLine__TailAssignment_1_133356 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgLine_in_rule__ExplicitArgList__LinesAssignment_033387 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgLine_in_rule__ExplicitArgList__LinesAssignment_1_0_133418 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgLine_in_rule__ExplicitArgList__LinesAssignment_1_1_133449 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitArgList_in_rule__ArgList__DummyAssignment_1_033480 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitArgList_in_rule__ArgList__DummyAssignment_1_1_133511 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitDictItems_in_rule__DictItems__DummyAssignment_1_033542 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitDictItems_in_rule__DictItems__DummyAssignment_1_1_133573 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictLine_in_rule__ExplicitDictItems__LinesAssignment_033604 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictLine_in_rule__ExplicitDictItems__LinesAssignment_1_0_133635 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictLine_in_rule__ExplicitDictItems__LinesAssignment_1_1_133666 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItem_in_rule__DictLine__HeadAssignment_033697 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItem_in_rule__DictLine__TailAssignment_1_133728 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictKey_in_rule__DictItem__KeyAssignment_133759 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__DictItem__ValueAssignment_2_1_033790 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__DictItem__ValueAssignment_2_1_1_133821 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParam_in_rule__Lambda__ParamsAssignment_0_1_033852 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParam_in_rule__Lambda__ParamsAssignment_0_1_1_133883 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_rule__Lambda__BodyAssignment_233914 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_rule__Param__SplatAssignment_1_033945 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_rule__Param__DefaultValueAssignment_1_1_133976 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBody_in_rule__Parenthetical__ContentAssignment_0_134007 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBody_in_rule__Parenthetical__ContentAssignment_1_134038 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Assignment__Group_0__0_in_synpred20_InternalCakefile4832 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Index__Group_1__0_in_synpred36_InternalCakefile5498 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRange_in_synpred42_InternalCakefile5699 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArray_in_synpred43_InternalCakefile5718 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Alternatives_1_in_synpred89_InternalCakefile10440 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_2_3__0_in_synpred90_InternalCakefile11054 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__Postfix__Group_1_3_3__0_in_synpred91_InternalCakefile11424 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_0_2__0_in_synpred94_InternalCakefile12223 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Alternatives_1_1_2_in_synpred95_InternalCakefile12530 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_0_2__0_in_synpred96_InternalCakefile12715 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ForSource__Group_1_1_2_1_2__0_in_synpred97_InternalCakefile13022 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__LogicOp__Group_1__0_in_synpred98_InternalCakefile14171 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__CompareOp__Group_1__0_in_synpred99_InternalCakefile14594 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__RelationOp__Group_1__0_in_synpred100_InternalCakefile15017 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__ShiftOp__Group_1__0_in_synpred101_InternalCakefile15440 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__AdditiveOp__Group_1__0_in_synpred102_InternalCakefile15863 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rule__MathOp__Group_1__0_in_synpred103_InternalCakefile16286 = new BitSet(new long[]{0x0000000000000002L});
+
+}
\ No newline at end of file
diff --git a/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/internal/CakefileActivator.java b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/internal/CakefileActivator.java
new file mode 100644
index 0000000..ae870d1
--- /dev/null
+++ b/example/csep.example.cake.ui/src-gen/csep/example/cake/ui/internal/CakefileActivator.java
@@ -0,0 +1,95 @@
+/*
+ * generated by Xtext
+ */
+package csep.example.cake.ui.internal;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.apache.log4j.Logger;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.eclipse.xtext.ui.shared.SharedStateModule;
+import org.eclipse.xtext.util.Modules2;
+import org.osgi.framework.BundleContext;
+
+import com.google.common.collect.Maps;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.Module;
+
+/**
+ * This class was generated. Customizations should only happen in a newly
+ * introduced subclass.
+ */
+public class CakefileActivator extends AbstractUIPlugin {
+
+ public static final String CSEP_EXAMPLE_CAKE_CAKEFILE = "csep.example.cake.Cakefile";
+
+ private static final Logger logger = Logger.getLogger(CakefileActivator.class);
+
+ private static CakefileActivator INSTANCE;
+
+ private Map injectors = Collections.synchronizedMap(Maps. newHashMapWithExpectedSize(1));
+
+ @Override
+ public void start(BundleContext context) throws Exception {
+ super.start(context);
+ INSTANCE = this;
+ }
+
+ @Override
+ public void stop(BundleContext context) throws Exception {
+ injectors.clear();
+ INSTANCE = null;
+ super.stop(context);
+ }
+
+ public static CakefileActivator getInstance() {
+ return INSTANCE;
+ }
+
+ public Injector getInjector(String language) {
+ synchronized (injectors) {
+ Injector injector = injectors.get(language);
+ if (injector == null) {
+ injectors.put(language, injector = createInjector(language));
+ }
+ return injector;
+ }
+ }
+
+ protected Injector createInjector(String language) {
+ try {
+ Module runtimeModule = getRuntimeModule(language);
+ Module sharedStateModule = getSharedStateModule();
+ Module uiModule = getUiModule(language);
+ Module mergedModule = Modules2.mixin(runtimeModule, sharedStateModule, uiModule);
+ return Guice.createInjector(mergedModule);
+ } catch (Exception e) {
+ logger.error("Failed to create injector for " + language);
+ logger.error(e.getMessage(), e);
+ throw new RuntimeException("Failed to create injector for " + language, e);
+ }
+ }
+
+ protected Module getRuntimeModule(String grammar) {
+ if (CSEP_EXAMPLE_CAKE_CAKEFILE.equals(grammar)) {
+ return new csep.example.cake.CakefileRuntimeModule();
+ }
+
+ throw new IllegalArgumentException(grammar);
+ }
+
+ protected Module getUiModule(String grammar) {
+ if (CSEP_EXAMPLE_CAKE_CAKEFILE.equals(grammar)) {
+ return new csep.example.cake.ui.CakefileUiModule(this);
+ }
+
+ throw new IllegalArgumentException(grammar);
+ }
+
+ protected Module getSharedStateModule() {
+ return new SharedStateModule();
+ }
+
+}
diff --git a/example/csep.example.cake/META-INF/MANIFEST.MF b/example/csep.example.cake/META-INF/MANIFEST.MF
index b6d8941..65ccff9 100644
--- a/example/csep.example.cake/META-INF/MANIFEST.MF
+++ b/example/csep.example.cake/META-INF/MANIFEST.MF
@@ -20,12 +20,11 @@ Require-Bundle: org.eclipse.xtext;bundle-version="2.1.0";visibility:=reexport,
org.eclipse.xtext.common.types,
org.eclipse.core.runtime;bundle-version="3.7.0",
org.eclipse.core.resources;bundle-version="3.7.100",
- csep;bundle-version="0.2.1";visibility:=reexport,
- csep.ui;bundle-version="0.2.1";visibility:=reexport
+ csep,
+ csep.ui
Import-Package: org.apache.commons.logging,
org.apache.log4j,
- org.eclipse.xtext.xbase.lib,
- org.eclipse.xtext.xtend2.lib
+ org.eclipse.xtext.xbase.lib
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Export-Package: csep.example.cake,
csep.example.cake.services,
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/AbstractCakefileRuntimeModule.java b/example/csep.example.cake/src-gen/csep/example/cake/AbstractCakefileRuntimeModule.java
new file mode 100644
index 0000000..36fa33b
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/AbstractCakefileRuntimeModule.java
@@ -0,0 +1,162 @@
+/*
+ * generated by Xtext
+ */
+package csep.example.cake;
+
+import java.util.Properties;
+
+import org.eclipse.xtext.Constants;
+import org.eclipse.xtext.service.DefaultRuntimeModule;
+
+import com.google.inject.Binder;
+import com.google.inject.name.Names;
+
+/**
+ * Manual modifications go to {csep.example.cake.CakefileRuntimeModule}
+ */
+ @SuppressWarnings("all")
+public abstract class AbstractCakefileRuntimeModule extends DefaultRuntimeModule {
+
+ protected Properties properties = null;
+
+ @Override
+ public void configure(Binder binder) {
+ properties = tryBindProperties(binder, "csep/example/cake/Cakefile.properties");
+ super.configure(binder);
+ }
+
+ public void configureLanguageName(Binder binder) {
+ binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("csep.example.cake.Cakefile");
+ }
+
+ public void configureFileExtensions(Binder binder) {
+ if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null)
+ binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("Cakefile");
+ }
+
+ // contributed by org.eclipse.xtext.generator.grammarAccess.GrammarAccessFragment
+ public Class bindIGrammarAccess() {
+ return csep.example.cake.services.CakefileGrammarAccess.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parseTreeConstructor.ParseTreeConstructorFragment
+ public Class bindIParseTreeConstructor() {
+ return csep.example.cake.parseTreeConstruction.CakefileParsetreeConstructor.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public Class bindIParser() {
+ return csep.example.cake.parser.antlr.CakefileParser.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public Class bindITokenToStringConverter() {
+ return org.eclipse.xtext.parser.antlr.AntlrTokenToStringConverter.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public Class bindIAntlrTokenFileProvider() {
+ return csep.example.cake.parser.antlr.CakefileAntlrTokenFileProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public Class bindLexer() {
+ return csep.example.cake.parser.antlr.internal.InternalCakefileLexer.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public com.google.inject.Provider provideInternalCakefileLexer() {
+ return org.eclipse.xtext.parser.antlr.LexerProvider.create(csep.example.cake.parser.antlr.internal.InternalCakefileLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public void configureRuntimeLexer(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.parser.antlr.LexerBindings.RUNTIME)).to(csep.example.cake.parser.antlr.internal.InternalCakefileLexer.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+ public Class bindITokenDefProvider() {
+ return org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.validation.JavaValidatorFragment
+ @org.eclipse.xtext.service.SingletonBinding(eager=true) public Class bindCakefileJavaValidator() {
+ return csep.example.cake.validation.CakefileJavaValidator.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.scoping.AbstractScopingFragment
+ public Class bindIScopeProvider() {
+ return csep.example.cake.scoping.CakefileScopeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.scoping.AbstractScopingFragment
+ public void configureIScopeProviderDelegate(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.scoping.IScopeProvider.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.scoping.AbstractScopingFragment
+ public void configureIgnoreCaseLinking(com.google.inject.Binder binder) {
+ binder.bindConstant().annotatedWith(org.eclipse.xtext.scoping.IgnoreCaseLinking.class).to(false);
+ }
+
+ // contributed by org.eclipse.xtext.generator.exporting.QualifiedNamesFragment
+ public Class bindIQualifiedNameProvider() {
+ return org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment
+ public Class bindIContainer$Manager() {
+ return org.eclipse.xtext.resource.containers.StateBasedContainerManager.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment
+ public Class bindIAllContainersState$Provider() {
+ return org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment
+ public void configureIResourceDescriptions(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.resource.IResourceDescriptions.class).to(org.eclipse.xtext.resource.impl.ResourceSetBasedResourceDescriptions.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment
+ public void configureIResourceDescriptionsBuilderScope(com.google.inject.Binder binder) {
+ binder.bind(org.eclipse.xtext.resource.IResourceDescriptions.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(org.eclipse.xtext.resource.impl.ResourceSetBasedResourceDescriptions.class);
+ }
+
+ // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment
+ public Class bindIGenerator() {
+ return csep.example.cake.generator.CakefileGenerator.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.formatting.FormatterFragment
+ public Class bindIFormatter() {
+ return csep.example.cake.formatting.CakefileFormatter.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public java.lang.ClassLoader bindClassLoaderToInstance() {
+ return getClass().getClassLoader();
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public org.eclipse.xtext.common.types.TypesFactory bindTypesFactoryToInstance() {
+ return org.eclipse.xtext.common.types.TypesFactory.eINSTANCE;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindIJvmTypeProvider$Factory() {
+ return org.eclipse.xtext.common.types.access.ClasspathTypeProviderFactory.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindAbstractTypeScopeProvider() {
+ return org.eclipse.xtext.common.types.xtext.ClasspathBasedTypeScopeProvider.class;
+ }
+
+ // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment
+ public Class bindIGlobalScopeProvider() {
+ return org.eclipse.xtext.common.types.xtext.TypesAwareDefaultGlobalScopeProvider.class;
+ }
+
+}
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/Cakefile.ecore b/example/csep.example.cake/src-gen/csep/example/cake/Cakefile.ecore
new file mode 100644
index 0000000..069a48c
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/Cakefile.ecore
@@ -0,0 +1,18 @@
+
+
+
+
+
+
+
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/Cakefile.genmodel b/example/csep.example.cake/src-gen/csep/example/cake/Cakefile.genmodel
new file mode 100644
index 0000000..c461035
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/Cakefile.genmodel
@@ -0,0 +1,20 @@
+
+
+
+
+
+
+
+
+
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/Cakefile.xmi b/example/csep.example.cake/src-gen/csep/example/cake/Cakefile.xmi
new file mode 100644
index 0000000..2ed54e4
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/Cakefile.xmi
@@ -0,0 +1,2215 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/CakefileStandaloneSetupGenerated.java b/example/csep.example.cake/src-gen/csep/example/cake/CakefileStandaloneSetupGenerated.java
new file mode 100644
index 0000000..7499328
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/CakefileStandaloneSetupGenerated.java
@@ -0,0 +1,45 @@
+/*
+* generated by Xtext
+*/
+package csep.example.cake;
+
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.xtext.ISetup;
+import org.eclipse.emf.ecore.resource.Resource;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+
+/**
+ * Generated from StandaloneSetup.xpt!
+ */
+@SuppressWarnings("all")
+public class CakefileStandaloneSetupGenerated implements ISetup {
+
+ public Injector createInjectorAndDoEMFRegistration() {
+ csep.CoffeeScriptStandaloneSetup.doSetup();
+
+ Injector injector = createInjector();
+ register(injector);
+ return injector;
+ }
+
+ public Injector createInjector() {
+ return Guice.createInjector(new csep.example.cake.CakefileRuntimeModule());
+ }
+
+ public void register(Injector injector) {
+ if (!EPackage.Registry.INSTANCE.containsKey("http://www.example.csep/cake/Cakefile")) {
+ EPackage.Registry.INSTANCE.put("http://www.example.csep/cake/Cakefile", csep.example.cake.cakefile.CakefilePackage.eINSTANCE);
+ }
+
+ org.eclipse.xtext.resource.IResourceFactory resourceFactory = injector.getInstance(org.eclipse.xtext.resource.IResourceFactory.class);
+ org.eclipse.xtext.resource.IResourceServiceProvider serviceProvider = injector.getInstance(org.eclipse.xtext.resource.IResourceServiceProvider.class);
+ Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("Cakefile", resourceFactory);
+ org.eclipse.xtext.resource.IResourceServiceProvider.Registry.INSTANCE.getExtensionToFactoryMap().put("Cakefile", serviceProvider);
+
+
+
+
+ }
+}
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/cakefile/Cakefile.java b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/Cakefile.java
new file mode 100644
index 0000000..ae96972
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/Cakefile.java
@@ -0,0 +1,43 @@
+/**
+ */
+package csep.example.cake.cakefile;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ *
+ * A representation of the model object 'Cakefile
+ * The following features are supported:
+ *
+ * {@link csep.example.cake.cakefile.Cakefile#getTasks Tasks }
+ *
+ *
+ *
+ * @see csep.example.cake.cakefile.CakefilePackage#getCakefile()
+ * @model
+ * @generated
+ */
+public interface Cakefile extends EObject
+{
+ /**
+ * Returns the value of the 'Tasks
+ * If the meaning of the 'Tasks ' containment reference list isn't clear,
+ * there really should be more of a description here...
+ *
+ *
+ * @return the value of the 'Tasks ' containment reference list.
+ * @see csep.example.cake.cakefile.CakefilePackage#getCakefile_Tasks()
+ * @model containment="true"
+ * @generated
+ */
+ EList getTasks();
+
+} // Cakefile
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/cakefile/CakefileFactory.java b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/CakefileFactory.java
new file mode 100644
index 0000000..dad6685
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/CakefileFactory.java
@@ -0,0 +1,52 @@
+/**
+ */
+package csep.example.cake.cakefile;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ *
+ * The Factory for the model.
+ * It provides a create method for each non-abstract class of the model.
+ *
+ * @see csep.example.cake.cakefile.CakefilePackage
+ * @generated
+ */
+public interface CakefileFactory extends EFactory
+{
+ /**
+ * The singleton instance of the factory.
+ *
+ *
+ * @generated
+ */
+ CakefileFactory eINSTANCE = csep.example.cake.cakefile.impl.CakefileFactoryImpl.init();
+
+ /**
+ * Returns a new object of class 'Cakefile '.
+ *
+ *
+ * @return a new object of class 'Cakefile '.
+ * @generated
+ */
+ Cakefile createCakefile();
+
+ /**
+ * Returns a new object of class 'Task Declaration '.
+ *
+ *
+ * @return a new object of class 'Task Declaration '.
+ * @generated
+ */
+ TaskDeclaration createTaskDeclaration();
+
+ /**
+ * Returns the package supported by this factory.
+ *
+ *
+ * @return the package supported by this factory.
+ * @generated
+ */
+ CakefilePackage getCakefilePackage();
+
+} //CakefileFactory
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/cakefile/CakefilePackage.java b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/CakefilePackage.java
new file mode 100644
index 0000000..fd479bd
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/CakefilePackage.java
@@ -0,0 +1,302 @@
+/**
+ */
+package csep.example.cake.cakefile;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+/**
+ *
+ * The Package for the model.
+ * It contains accessors for the meta objects to represent
+ *
+ * each class,
+ * each feature of each class,
+ * each enum,
+ * and each data type
+ *
+ *
+ * @see csep.example.cake.cakefile.CakefileFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface CakefilePackage extends EPackage
+{
+ /**
+ * The package name.
+ *
+ *
+ * @generated
+ */
+ String eNAME = "cakefile";
+
+ /**
+ * The package namespace URI.
+ *
+ *
+ * @generated
+ */
+ String eNS_URI = "http://www.example.csep/cake/Cakefile";
+
+ /**
+ * The package namespace name.
+ *
+ *
+ * @generated
+ */
+ String eNS_PREFIX = "cakefile";
+
+ /**
+ * The singleton instance of the package.
+ *
+ *
+ * @generated
+ */
+ CakefilePackage eINSTANCE = csep.example.cake.cakefile.impl.CakefilePackageImpl.init();
+
+ /**
+ * The meta object id for the '{@link csep.example.cake.cakefile.impl.CakefileImpl Cakefile }' class.
+ *
+ *
+ * @see csep.example.cake.cakefile.impl.CakefileImpl
+ * @see csep.example.cake.cakefile.impl.CakefilePackageImpl#getCakefile()
+ * @generated
+ */
+ int CAKEFILE = 0;
+
+ /**
+ * The feature id for the 'Tasks Cakefile ' class.
+ *
+ *
+ * @generated
+ * @ordered
+ */
+ int CAKEFILE_FEATURE_COUNT = 1;
+
+ /**
+ * The meta object id for the '{@link csep.example.cake.cakefile.impl.TaskDeclarationImpl Task Declaration }' class.
+ *
+ *
+ * @see csep.example.cake.cakefile.impl.TaskDeclarationImpl
+ * @see csep.example.cake.cakefile.impl.CakefilePackageImpl#getTaskDeclaration()
+ * @generated
+ */
+ int TASK_DECLARATION = 1;
+
+ /**
+ * The feature id for the 'Name Description Options Body Task Declaration ' class.
+ *
+ *
+ * @generated
+ * @ordered
+ */
+ int TASK_DECLARATION_FEATURE_COUNT = 4;
+
+
+ /**
+ * Returns the meta object for class '{@link csep.example.cake.cakefile.Cakefile Cakefile }'.
+ *
+ *
+ * @return the meta object for class 'Cakefile '.
+ * @see csep.example.cake.cakefile.Cakefile
+ * @generated
+ */
+ EClass getCakefile();
+
+ /**
+ * Returns the meta object for the containment reference list '{@link csep.example.cake.cakefile.Cakefile#getTasks Tasks }'.
+ *
+ *
+ * @return the meta object for the containment reference list 'Tasks '.
+ * @see csep.example.cake.cakefile.Cakefile#getTasks()
+ * @see #getCakefile()
+ * @generated
+ */
+ EReference getCakefile_Tasks();
+
+ /**
+ * Returns the meta object for class '{@link csep.example.cake.cakefile.TaskDeclaration Task Declaration }'.
+ *
+ *
+ * @return the meta object for class 'Task Declaration '.
+ * @see csep.example.cake.cakefile.TaskDeclaration
+ * @generated
+ */
+ EClass getTaskDeclaration();
+
+ /**
+ * Returns the meta object for the containment reference '{@link csep.example.cake.cakefile.TaskDeclaration#getName Name }'.
+ *
+ *
+ * @return the meta object for the containment reference 'Name '.
+ * @see csep.example.cake.cakefile.TaskDeclaration#getName()
+ * @see #getTaskDeclaration()
+ * @generated
+ */
+ EReference getTaskDeclaration_Name();
+
+ /**
+ * Returns the meta object for the containment reference '{@link csep.example.cake.cakefile.TaskDeclaration#getDescription Description }'.
+ *
+ *
+ * @return the meta object for the containment reference 'Description '.
+ * @see csep.example.cake.cakefile.TaskDeclaration#getDescription()
+ * @see #getTaskDeclaration()
+ * @generated
+ */
+ EReference getTaskDeclaration_Description();
+
+ /**
+ * Returns the meta object for the containment reference '{@link csep.example.cake.cakefile.TaskDeclaration#getOptions Options }'.
+ *
+ *
+ * @return the meta object for the containment reference 'Options '.
+ * @see csep.example.cake.cakefile.TaskDeclaration#getOptions()
+ * @see #getTaskDeclaration()
+ * @generated
+ */
+ EReference getTaskDeclaration_Options();
+
+ /**
+ * Returns the meta object for the containment reference '{@link csep.example.cake.cakefile.TaskDeclaration#getBody Body }'.
+ *
+ *
+ * @return the meta object for the containment reference 'Body '.
+ * @see csep.example.cake.cakefile.TaskDeclaration#getBody()
+ * @see #getTaskDeclaration()
+ * @generated
+ */
+ EReference getTaskDeclaration_Body();
+
+ /**
+ * Returns the factory that creates the instances of the model.
+ *
+ *
+ * @return the factory that creates the instances of the model.
+ * @generated
+ */
+ CakefileFactory getCakefileFactory();
+
+ /**
+ *
+ * Defines literals for the meta objects that represent
+ *
+ * each class,
+ * each feature of each class,
+ * each enum,
+ * and each data type
+ *
+ *
+ * @generated
+ */
+ interface Literals
+ {
+ /**
+ * The meta object literal for the '{@link csep.example.cake.cakefile.impl.CakefileImpl Cakefile }' class.
+ *
+ *
+ * @see csep.example.cake.cakefile.impl.CakefileImpl
+ * @see csep.example.cake.cakefile.impl.CakefilePackageImpl#getCakefile()
+ * @generated
+ */
+ EClass CAKEFILE = eINSTANCE.getCakefile();
+
+ /**
+ * The meta object literal for the 'Tasks Task Declaration }' class.
+ *
+ *
+ * @see csep.example.cake.cakefile.impl.TaskDeclarationImpl
+ * @see csep.example.cake.cakefile.impl.CakefilePackageImpl#getTaskDeclaration()
+ * @generated
+ */
+ EClass TASK_DECLARATION = eINSTANCE.getTaskDeclaration();
+
+ /**
+ * The meta object literal for the 'Name Description Options Body Task Declaration
+ * The following features are supported:
+ *
+ * {@link csep.example.cake.cakefile.TaskDeclaration#getName Name }
+ * {@link csep.example.cake.cakefile.TaskDeclaration#getDescription Description }
+ * {@link csep.example.cake.cakefile.TaskDeclaration#getOptions Options }
+ * {@link csep.example.cake.cakefile.TaskDeclaration#getBody Body }
+ *
+ *
+ *
+ * @see csep.example.cake.cakefile.CakefilePackage#getTaskDeclaration()
+ * @model
+ * @generated
+ */
+public interface TaskDeclaration extends EObject
+{
+ /**
+ * Returns the value of the 'Name
+ * If the meaning of the 'Name ' containment reference isn't clear,
+ * there really should be more of a description here...
+ *
+ *
+ * @return the value of the 'Name ' containment reference.
+ * @see #setName(StringLiteral)
+ * @see csep.example.cake.cakefile.CakefilePackage#getTaskDeclaration_Name()
+ * @model containment="true"
+ * @generated
+ */
+ StringLiteral getName();
+
+ /**
+ * Sets the value of the '{@link csep.example.cake.cakefile.TaskDeclaration#getName Name }' containment reference.
+ *
+ *
+ * @param value the new value of the 'Name ' containment reference.
+ * @see #getName()
+ * @generated
+ */
+ void setName(StringLiteral value);
+
+ /**
+ * Returns the value of the 'Description
+ * If the meaning of the 'Description ' containment reference isn't clear,
+ * there really should be more of a description here...
+ *
+ *
+ * @return the value of the 'Description ' containment reference.
+ * @see #setDescription(StringLiteral)
+ * @see csep.example.cake.cakefile.CakefilePackage#getTaskDeclaration_Description()
+ * @model containment="true"
+ * @generated
+ */
+ StringLiteral getDescription();
+
+ /**
+ * Sets the value of the '{@link csep.example.cake.cakefile.TaskDeclaration#getDescription Description }' containment reference.
+ *
+ *
+ * @param value the new value of the 'Description ' containment reference.
+ * @see #getDescription()
+ * @generated
+ */
+ void setDescription(StringLiteral value);
+
+ /**
+ * Returns the value of the 'Options
+ * If the meaning of the 'Options ' containment reference isn't clear,
+ * there really should be more of a description here...
+ *
+ *
+ * @return the value of the 'Options ' containment reference.
+ * @see #setOptions(Id)
+ * @see csep.example.cake.cakefile.CakefilePackage#getTaskDeclaration_Options()
+ * @model containment="true"
+ * @generated
+ */
+ Id getOptions();
+
+ /**
+ * Sets the value of the '{@link csep.example.cake.cakefile.TaskDeclaration#getOptions Options }' containment reference.
+ *
+ *
+ * @param value the new value of the 'Options ' containment reference.
+ * @see #getOptions()
+ * @generated
+ */
+ void setOptions(Id value);
+
+ /**
+ * Returns the value of the 'Body
+ * If the meaning of the 'Body ' containment reference isn't clear,
+ * there really should be more of a description here...
+ *
+ *
+ * @return the value of the 'Body ' containment reference.
+ * @see #setBody(Block)
+ * @see csep.example.cake.cakefile.CakefilePackage#getTaskDeclaration_Body()
+ * @model containment="true"
+ * @generated
+ */
+ Block getBody();
+
+ /**
+ * Sets the value of the '{@link csep.example.cake.cakefile.TaskDeclaration#getBody Body }' containment reference.
+ *
+ *
+ * @param value the new value of the 'Body ' containment reference.
+ * @see #getBody()
+ * @generated
+ */
+ void setBody(Block value);
+
+} // TaskDeclaration
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/CakefileFactoryImpl.java b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/CakefileFactoryImpl.java
new file mode 100644
index 0000000..9bd6033
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/CakefileFactoryImpl.java
@@ -0,0 +1,118 @@
+/**
+ */
+package csep.example.cake.cakefile.impl;
+
+import csep.example.cake.cakefile.*;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+/**
+ *
+ * An implementation of the model Factory .
+ *
+ * @generated
+ */
+public class CakefileFactoryImpl extends EFactoryImpl implements CakefileFactory
+{
+ /**
+ * Creates the default factory implementation.
+ *
+ *
+ * @generated
+ */
+ public static CakefileFactory init()
+ {
+ try
+ {
+ CakefileFactory theCakefileFactory = (CakefileFactory)EPackage.Registry.INSTANCE.getEFactory("http://www.example.csep/cake/Cakefile");
+ if (theCakefileFactory != null)
+ {
+ return theCakefileFactory;
+ }
+ }
+ catch (Exception exception)
+ {
+ EcorePlugin.INSTANCE.log(exception);
+ }
+ return new CakefileFactoryImpl();
+ }
+
+ /**
+ * Creates an instance of the factory.
+ *
+ *
+ * @generated
+ */
+ public CakefileFactoryImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public EObject create(EClass eClass)
+ {
+ switch (eClass.getClassifierID())
+ {
+ case CakefilePackage.CAKEFILE: return createCakefile();
+ case CakefilePackage.TASK_DECLARATION: return createTaskDeclaration();
+ default:
+ throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+ }
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Cakefile createCakefile()
+ {
+ CakefileImpl cakefile = new CakefileImpl();
+ return cakefile;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public TaskDeclaration createTaskDeclaration()
+ {
+ TaskDeclarationImpl taskDeclaration = new TaskDeclarationImpl();
+ return taskDeclaration;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public CakefilePackage getCakefilePackage()
+ {
+ return (CakefilePackage)getEPackage();
+ }
+
+ /**
+ *
+ *
+ * @deprecated
+ * @generated
+ */
+ @Deprecated
+ public static CakefilePackage getPackage()
+ {
+ return CakefilePackage.eINSTANCE;
+ }
+
+} //CakefileFactoryImpl
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/CakefileImpl.java b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/CakefileImpl.java
new file mode 100644
index 0000000..ffa5779
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/CakefileImpl.java
@@ -0,0 +1,167 @@
+/**
+ */
+package csep.example.cake.cakefile.impl;
+
+import csep.example.cake.cakefile.Cakefile;
+import csep.example.cake.cakefile.CakefilePackage;
+import csep.example.cake.cakefile.TaskDeclaration;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Cakefile
+ * The following features are implemented:
+ *
+ * {@link csep.example.cake.cakefile.impl.CakefileImpl#getTasks Tasks }
+ *
+ *
+ *
+ * @generated
+ */
+public class CakefileImpl extends MinimalEObjectImpl.Container implements Cakefile
+{
+ /**
+ * The cached value of the '{@link #getTasks() Tasks }' containment reference list.
+ *
+ *
+ * @see #getTasks()
+ * @generated
+ * @ordered
+ */
+ protected EList tasks;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected CakefileImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CakefilePackage.Literals.CAKEFILE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getTasks()
+ {
+ if (tasks == null)
+ {
+ tasks = new EObjectContainmentEList(TaskDeclaration.class, this, CakefilePackage.CAKEFILE__TASKS);
+ }
+ return tasks;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.CAKEFILE__TASKS:
+ return ((InternalEList)getTasks()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.CAKEFILE__TASKS:
+ return getTasks();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.CAKEFILE__TASKS:
+ getTasks().clear();
+ getTasks().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.CAKEFILE__TASKS:
+ getTasks().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.CAKEFILE__TASKS:
+ return tasks != null && !tasks.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //CakefileImpl
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/CakefilePackageImpl.java b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/CakefilePackageImpl.java
new file mode 100644
index 0000000..8f94e4d
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/CakefilePackageImpl.java
@@ -0,0 +1,263 @@
+/**
+ */
+package csep.example.cake.cakefile.impl;
+
+import csep.coffeeScript.CoffeeScriptPackage;
+
+import csep.example.cake.cakefile.Cakefile;
+import csep.example.cake.cakefile.CakefileFactory;
+import csep.example.cake.cakefile.CakefilePackage;
+import csep.example.cake.cakefile.TaskDeclaration;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+/**
+ *
+ * An implementation of the model Package .
+ *
+ * @generated
+ */
+public class CakefilePackageImpl extends EPackageImpl implements CakefilePackage
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass cakefileEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass taskDeclarationEClass = null;
+
+ /**
+ * Creates an instance of the model Package , registered with
+ * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+ * package URI value.
+ * Note: the correct way to create the package is via the static
+ * factory method {@link #init init()}, which also performs
+ * initialization of the package, or returns the registered package,
+ * if one already exists.
+ *
+ *
+ * @see org.eclipse.emf.ecore.EPackage.Registry
+ * @see csep.example.cake.cakefile.CakefilePackage#eNS_URI
+ * @see #init()
+ * @generated
+ */
+ private CakefilePackageImpl()
+ {
+ super(eNS_URI, CakefileFactory.eINSTANCE);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private static boolean isInited = false;
+
+ /**
+ * Creates, registers, and initializes the Package for this model, and for any others upon which it depends.
+ *
+ *
This method is used to initialize {@link CakefilePackage#eINSTANCE} when that field is accessed.
+ * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+ *
+ *
+ * @see #eNS_URI
+ * @see #createPackageContents()
+ * @see #initializePackageContents()
+ * @generated
+ */
+ public static CakefilePackage init()
+ {
+ if (isInited) return (CakefilePackage)EPackage.Registry.INSTANCE.getEPackage(CakefilePackage.eNS_URI);
+
+ // Obtain or create and register package
+ CakefilePackageImpl theCakefilePackage = (CakefilePackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof CakefilePackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new CakefilePackageImpl());
+
+ isInited = true;
+
+ // Initialize simple dependencies
+ CoffeeScriptPackage.eINSTANCE.eClass();
+
+ // Create package meta-data objects
+ theCakefilePackage.createPackageContents();
+
+ // Initialize created meta-data
+ theCakefilePackage.initializePackageContents();
+
+ // Mark meta-data to indicate it can't be changed
+ theCakefilePackage.freeze();
+
+
+ // Update the registry and return the package
+ EPackage.Registry.INSTANCE.put(CakefilePackage.eNS_URI, theCakefilePackage);
+ return theCakefilePackage;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getCakefile()
+ {
+ return cakefileEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getCakefile_Tasks()
+ {
+ return (EReference)cakefileEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getTaskDeclaration()
+ {
+ return taskDeclarationEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTaskDeclaration_Name()
+ {
+ return (EReference)taskDeclarationEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTaskDeclaration_Description()
+ {
+ return (EReference)taskDeclarationEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTaskDeclaration_Options()
+ {
+ return (EReference)taskDeclarationEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTaskDeclaration_Body()
+ {
+ return (EReference)taskDeclarationEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public CakefileFactory getCakefileFactory()
+ {
+ return (CakefileFactory)getEFactoryInstance();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private boolean isCreated = false;
+
+ /**
+ * Creates the meta-model objects for the package. This method is
+ * guarded to have no affect on any invocation but its first.
+ *
+ *
+ * @generated
+ */
+ public void createPackageContents()
+ {
+ if (isCreated) return;
+ isCreated = true;
+
+ // Create classes and their features
+ cakefileEClass = createEClass(CAKEFILE);
+ createEReference(cakefileEClass, CAKEFILE__TASKS);
+
+ taskDeclarationEClass = createEClass(TASK_DECLARATION);
+ createEReference(taskDeclarationEClass, TASK_DECLARATION__NAME);
+ createEReference(taskDeclarationEClass, TASK_DECLARATION__DESCRIPTION);
+ createEReference(taskDeclarationEClass, TASK_DECLARATION__OPTIONS);
+ createEReference(taskDeclarationEClass, TASK_DECLARATION__BODY);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private boolean isInitialized = false;
+
+ /**
+ * Complete the initialization of the package and its meta-model. This
+ * method is guarded to have no affect on any invocation but its first.
+ *
+ *
+ * @generated
+ */
+ public void initializePackageContents()
+ {
+ if (isInitialized) return;
+ isInitialized = true;
+
+ // Initialize package
+ setName(eNAME);
+ setNsPrefix(eNS_PREFIX);
+ setNsURI(eNS_URI);
+
+ // Obtain other dependent packages
+ CoffeeScriptPackage theCoffeeScriptPackage = (CoffeeScriptPackage)EPackage.Registry.INSTANCE.getEPackage(CoffeeScriptPackage.eNS_URI);
+
+ // Create type parameters
+
+ // Set bounds for type parameters
+
+ // Add supertypes to classes
+
+ // Initialize classes and features; add operations and parameters
+ initEClass(cakefileEClass, Cakefile.class, "Cakefile", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getCakefile_Tasks(), this.getTaskDeclaration(), null, "tasks", null, 0, -1, Cakefile.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(taskDeclarationEClass, TaskDeclaration.class, "TaskDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getTaskDeclaration_Name(), theCoffeeScriptPackage.getStringLiteral(), null, "name", null, 0, 1, TaskDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTaskDeclaration_Description(), theCoffeeScriptPackage.getStringLiteral(), null, "description", null, 0, 1, TaskDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTaskDeclaration_Options(), theCoffeeScriptPackage.getId(), null, "options", null, 0, 1, TaskDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTaskDeclaration_Body(), theCoffeeScriptPackage.getBlock(), null, "body", null, 0, 1, TaskDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ // Create resource
+ createResource(eNS_URI);
+ }
+
+} //CakefilePackageImpl
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/TaskDeclarationImpl.java b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/TaskDeclarationImpl.java
new file mode 100644
index 0000000..8cbf6fa
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/impl/TaskDeclarationImpl.java
@@ -0,0 +1,410 @@
+/**
+ */
+package csep.example.cake.cakefile.impl;
+
+import csep.coffeeScript.Block;
+import csep.coffeeScript.Id;
+import csep.coffeeScript.StringLiteral;
+
+import csep.example.cake.cakefile.CakefilePackage;
+import csep.example.cake.cakefile.TaskDeclaration;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Task Declaration
+ * The following features are implemented:
+ *
+ * {@link csep.example.cake.cakefile.impl.TaskDeclarationImpl#getName Name }
+ * {@link csep.example.cake.cakefile.impl.TaskDeclarationImpl#getDescription Description }
+ * {@link csep.example.cake.cakefile.impl.TaskDeclarationImpl#getOptions Options }
+ * {@link csep.example.cake.cakefile.impl.TaskDeclarationImpl#getBody Body }
+ *
+ *
+ *
+ * @generated
+ */
+public class TaskDeclarationImpl extends MinimalEObjectImpl.Container implements TaskDeclaration
+{
+ /**
+ * The cached value of the '{@link #getName() Name }' containment reference.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected StringLiteral name;
+
+ /**
+ * The cached value of the '{@link #getDescription() Description }' containment reference.
+ *
+ *
+ * @see #getDescription()
+ * @generated
+ * @ordered
+ */
+ protected StringLiteral description;
+
+ /**
+ * The cached value of the '{@link #getOptions() Options }' containment reference.
+ *
+ *
+ * @see #getOptions()
+ * @generated
+ * @ordered
+ */
+ protected Id options;
+
+ /**
+ * The cached value of the '{@link #getBody() Body }' containment reference.
+ *
+ *
+ * @see #getBody()
+ * @generated
+ * @ordered
+ */
+ protected Block body;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected TaskDeclarationImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return CakefilePackage.Literals.TASK_DECLARATION;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public StringLiteral getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetName(StringLiteral newName, NotificationChain msgs)
+ {
+ StringLiteral oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CakefilePackage.TASK_DECLARATION__NAME, oldName, newName);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(StringLiteral newName)
+ {
+ if (newName != name)
+ {
+ NotificationChain msgs = null;
+ if (name != null)
+ msgs = ((InternalEObject)name).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CakefilePackage.TASK_DECLARATION__NAME, null, msgs);
+ if (newName != null)
+ msgs = ((InternalEObject)newName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CakefilePackage.TASK_DECLARATION__NAME, null, msgs);
+ msgs = basicSetName(newName, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CakefilePackage.TASK_DECLARATION__NAME, newName, newName));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public StringLiteral getDescription()
+ {
+ return description;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDescription(StringLiteral newDescription, NotificationChain msgs)
+ {
+ StringLiteral oldDescription = description;
+ description = newDescription;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CakefilePackage.TASK_DECLARATION__DESCRIPTION, oldDescription, newDescription);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDescription(StringLiteral newDescription)
+ {
+ if (newDescription != description)
+ {
+ NotificationChain msgs = null;
+ if (description != null)
+ msgs = ((InternalEObject)description).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CakefilePackage.TASK_DECLARATION__DESCRIPTION, null, msgs);
+ if (newDescription != null)
+ msgs = ((InternalEObject)newDescription).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CakefilePackage.TASK_DECLARATION__DESCRIPTION, null, msgs);
+ msgs = basicSetDescription(newDescription, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CakefilePackage.TASK_DECLARATION__DESCRIPTION, newDescription, newDescription));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Id getOptions()
+ {
+ return options;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetOptions(Id newOptions, NotificationChain msgs)
+ {
+ Id oldOptions = options;
+ options = newOptions;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CakefilePackage.TASK_DECLARATION__OPTIONS, oldOptions, newOptions);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setOptions(Id newOptions)
+ {
+ if (newOptions != options)
+ {
+ NotificationChain msgs = null;
+ if (options != null)
+ msgs = ((InternalEObject)options).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CakefilePackage.TASK_DECLARATION__OPTIONS, null, msgs);
+ if (newOptions != null)
+ msgs = ((InternalEObject)newOptions).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CakefilePackage.TASK_DECLARATION__OPTIONS, null, msgs);
+ msgs = basicSetOptions(newOptions, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CakefilePackage.TASK_DECLARATION__OPTIONS, newOptions, newOptions));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Block getBody()
+ {
+ return body;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetBody(Block newBody, NotificationChain msgs)
+ {
+ Block oldBody = body;
+ body = newBody;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, CakefilePackage.TASK_DECLARATION__BODY, oldBody, newBody);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setBody(Block newBody)
+ {
+ if (newBody != body)
+ {
+ NotificationChain msgs = null;
+ if (body != null)
+ msgs = ((InternalEObject)body).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - CakefilePackage.TASK_DECLARATION__BODY, null, msgs);
+ if (newBody != null)
+ msgs = ((InternalEObject)newBody).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - CakefilePackage.TASK_DECLARATION__BODY, null, msgs);
+ msgs = basicSetBody(newBody, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, CakefilePackage.TASK_DECLARATION__BODY, newBody, newBody));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.TASK_DECLARATION__NAME:
+ return basicSetName(null, msgs);
+ case CakefilePackage.TASK_DECLARATION__DESCRIPTION:
+ return basicSetDescription(null, msgs);
+ case CakefilePackage.TASK_DECLARATION__OPTIONS:
+ return basicSetOptions(null, msgs);
+ case CakefilePackage.TASK_DECLARATION__BODY:
+ return basicSetBody(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.TASK_DECLARATION__NAME:
+ return getName();
+ case CakefilePackage.TASK_DECLARATION__DESCRIPTION:
+ return getDescription();
+ case CakefilePackage.TASK_DECLARATION__OPTIONS:
+ return getOptions();
+ case CakefilePackage.TASK_DECLARATION__BODY:
+ return getBody();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.TASK_DECLARATION__NAME:
+ setName((StringLiteral)newValue);
+ return;
+ case CakefilePackage.TASK_DECLARATION__DESCRIPTION:
+ setDescription((StringLiteral)newValue);
+ return;
+ case CakefilePackage.TASK_DECLARATION__OPTIONS:
+ setOptions((Id)newValue);
+ return;
+ case CakefilePackage.TASK_DECLARATION__BODY:
+ setBody((Block)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.TASK_DECLARATION__NAME:
+ setName((StringLiteral)null);
+ return;
+ case CakefilePackage.TASK_DECLARATION__DESCRIPTION:
+ setDescription((StringLiteral)null);
+ return;
+ case CakefilePackage.TASK_DECLARATION__OPTIONS:
+ setOptions((Id)null);
+ return;
+ case CakefilePackage.TASK_DECLARATION__BODY:
+ setBody((Block)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case CakefilePackage.TASK_DECLARATION__NAME:
+ return name != null;
+ case CakefilePackage.TASK_DECLARATION__DESCRIPTION:
+ return description != null;
+ case CakefilePackage.TASK_DECLARATION__OPTIONS:
+ return options != null;
+ case CakefilePackage.TASK_DECLARATION__BODY:
+ return body != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //TaskDeclarationImpl
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/cakefile/util/CakefileAdapterFactory.java b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/util/CakefileAdapterFactory.java
new file mode 100644
index 0000000..0e6b5c9
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/util/CakefileAdapterFactory.java
@@ -0,0 +1,152 @@
+/**
+ */
+package csep.example.cake.cakefile.util;
+
+import csep.example.cake.cakefile.*;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ *
+ * The Adapter Factory for the model.
+ * It provides an adapter createXXX method for each class of the model.
+ *
+ * @see csep.example.cake.cakefile.CakefilePackage
+ * @generated
+ */
+public class CakefileAdapterFactory extends AdapterFactoryImpl
+{
+ /**
+ * The cached model package.
+ *
+ *
+ * @generated
+ */
+ protected static CakefilePackage modelPackage;
+
+ /**
+ * Creates an instance of the adapter factory.
+ *
+ *
+ * @generated
+ */
+ public CakefileAdapterFactory()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = CakefilePackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Returns whether this factory is applicable for the type of the object.
+ *
+ * This implementation returns true if the object is either the model's package or is an instance object of the model.
+ *
+ * @return whether this factory is applicable for the type of the object.
+ * @generated
+ */
+ @Override
+ public boolean isFactoryForType(Object object)
+ {
+ if (object == modelPackage)
+ {
+ return true;
+ }
+ if (object instanceof EObject)
+ {
+ return ((EObject)object).eClass().getEPackage() == modelPackage;
+ }
+ return false;
+ }
+
+ /**
+ * The switch that delegates to the createXXX methods.
+ *
+ *
+ * @generated
+ */
+ protected CakefileSwitch modelSwitch =
+ new CakefileSwitch()
+ {
+ @Override
+ public Adapter caseCakefile(Cakefile object)
+ {
+ return createCakefileAdapter();
+ }
+ @Override
+ public Adapter caseTaskDeclaration(TaskDeclaration object)
+ {
+ return createTaskDeclarationAdapter();
+ }
+ @Override
+ public Adapter defaultCase(EObject object)
+ {
+ return createEObjectAdapter();
+ }
+ };
+
+ /**
+ * Creates an adapter for the target.
+ *
+ *
+ * @param target the object to adapt.
+ * @return the adapter for the target.
+ * @generated
+ */
+ @Override
+ public Adapter createAdapter(Notifier target)
+ {
+ return modelSwitch.doSwitch((EObject)target);
+ }
+
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.example.cake.cakefile.Cakefile Cakefile }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.example.cake.cakefile.Cakefile
+ * @generated
+ */
+ public Adapter createCakefileAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link csep.example.cake.cakefile.TaskDeclaration Task Declaration }'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see csep.example.cake.cakefile.TaskDeclaration
+ * @generated
+ */
+ public Adapter createTaskDeclarationAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for the default case.
+ *
+ * This default implementation returns null.
+ *
+ * @return the new adapter.
+ * @generated
+ */
+ public Adapter createEObjectAdapter()
+ {
+ return null;
+ }
+
+} //CakefileAdapterFactory
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/cakefile/util/CakefileSwitch.java b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/util/CakefileSwitch.java
new file mode 100644
index 0000000..3151c4e
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/cakefile/util/CakefileSwitch.java
@@ -0,0 +1,142 @@
+/**
+ */
+package csep.example.cake.cakefile.util;
+
+import csep.example.cake.cakefile.*;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+/**
+ *
+ * The Switch for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the caseXXX method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ *
+ * @see csep.example.cake.cakefile.CakefilePackage
+ * @generated
+ */
+public class CakefileSwitch extends Switch
+{
+ /**
+ * The cached model package
+ *
+ *
+ * @generated
+ */
+ protected static CakefilePackage modelPackage;
+
+ /**
+ * Creates an instance of the switch.
+ *
+ *
+ * @generated
+ */
+ public CakefileSwitch()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = CakefilePackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Checks whether this is a switch for the given package.
+ *
+ *
+ * @parameter ePackage the package in question.
+ * @return whether this is a switch for the given package.
+ * @generated
+ */
+ @Override
+ protected boolean isSwitchFor(EPackage ePackage)
+ {
+ return ePackage == modelPackage;
+ }
+
+ /**
+ * Calls caseXXX for each class of the model until one returns a non null result; it yields that result.
+ *
+ *
+ * @return the first non-null result returned by a caseXXX call.
+ * @generated
+ */
+ @Override
+ protected T doSwitch(int classifierID, EObject theEObject)
+ {
+ switch (classifierID)
+ {
+ case CakefilePackage.CAKEFILE:
+ {
+ Cakefile cakefile = (Cakefile)theEObject;
+ T result = caseCakefile(cakefile);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case CakefilePackage.TASK_DECLARATION:
+ {
+ TaskDeclaration taskDeclaration = (TaskDeclaration)theEObject;
+ T result = caseTaskDeclaration(taskDeclaration);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ default: return defaultCase(theEObject);
+ }
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Cakefile '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Cakefile '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseCakefile(Cakefile object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Task Declaration '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Task Declaration '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseTaskDeclaration(TaskDeclaration object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'EObject '.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch, but this is the last case anyway.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'EObject '.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+ * @generated
+ */
+ @Override
+ public T defaultCase(EObject object)
+ {
+ return null;
+ }
+
+} //CakefileSwitch
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/parseTreeConstruction/CakefileParsetreeConstructor.java b/example/csep.example.cake/src-gen/csep/example/cake/parseTreeConstruction/CakefileParsetreeConstructor.java
new file mode 100644
index 0000000..29339ac
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/parseTreeConstruction/CakefileParsetreeConstructor.java
@@ -0,0 +1,17925 @@
+/*
+* generated by Xtext
+*/
+package csep.example.cake.parseTreeConstruction;
+
+import org.eclipse.emf.ecore.*;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parsetree.reconstr.IEObjectConsumer;
+
+import csep.example.cake.services.CakefileGrammarAccess;
+
+import com.google.inject.Inject;
+
+@SuppressWarnings("all")
+public class CakefileParsetreeConstructor extends org.eclipse.xtext.parsetree.reconstr.impl.AbstractParseTreeConstructor {
+
+ @Inject
+ private CakefileGrammarAccess grammarAccess;
+
+ @Override
+ protected AbstractToken getRootToken(IEObjectConsumer inst) {
+ return new ThisRootNode(inst);
+ }
+
+protected class ThisRootNode extends RootToken {
+ public ThisRootNode(IEObjectConsumer inst) {
+ super(inst);
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Cakefile_TasksAssignment(this, this, 0, inst);
+ case 1: return new TaskDeclaration_Group(this, this, 1, inst);
+ case 2: return new Root_Alternatives(this, this, 2, inst);
+ case 3: return new Body_Group(this, this, 3, inst);
+ case 4: return new Line_Alternatives(this, this, 4, inst);
+ case 5: return new Stmt_Alternatives(this, this, 5, inst);
+ case 6: return new Comment_CommentAssignment(this, this, 6, inst);
+ case 7: return new RequireStmt_Group(this, this, 7, inst);
+ case 8: return new ReturnStmt_Group(this, this, 8, inst);
+ case 9: return new ThrowStmt_Group(this, this, 9, inst);
+ case 10: return new SuperClass_Alternatives(this, this, 10, inst);
+ case 11: return new ClassDeclaration_Group(this, this, 11, inst);
+ case 12: return new AssignedClassDeclaration_Group(this, this, 12, inst);
+ case 13: return new Expression_PostfixParserRuleCall(this, this, 13, inst);
+ case 14: return new Postfix_Group(this, this, 14, inst);
+ case 15: return new ForBody_Group(this, this, 15, inst);
+ case 16: return new ForValue_IdParserRuleCall(this, this, 16, inst);
+ case 17: return new ForSource_Group(this, this, 17, inst);
+ case 18: return new Range_Group(this, this, 18, inst);
+ case 19: return new Assignment_Alternatives(this, this, 19, inst);
+ case 20: return new Assigned_Alternatives(this, this, 20, inst);
+ case 21: return new LogicOp_Group(this, this, 21, inst);
+ case 22: return new CompareOp_Group(this, this, 22, inst);
+ case 23: return new RelationOp_Group(this, this, 23, inst);
+ case 24: return new ShiftOp_Group(this, this, 24, inst);
+ case 25: return new AdditiveOp_Group(this, this, 25, inst);
+ case 26: return new MathOp_Group(this, this, 26, inst);
+ case 27: return new UnaryOp_Alternatives(this, this, 27, inst);
+ case 28: return new Application_Alternatives(this, this, 28, inst);
+ case 29: return new FeatureCall_Alternatives(this, this, 29, inst);
+ case 30: return new FunctionCall_Group(this, this, 30, inst);
+ case 31: return new PropertyAccess_Alternatives(this, this, 31, inst);
+ case 32: return new ThisProperty_Group(this, this, 32, inst);
+ case 33: return new NamedPropertyAccess_Alternatives(this, this, 33, inst);
+ case 34: return new IndexedPropertyAccess_Group(this, this, 34, inst);
+ case 35: return new Index_Alternatives(this, this, 35, inst);
+ case 36: return new PrimaryExpression_Alternatives(this, this, 36, inst);
+ case 37: return new Block_Group(this, this, 37, inst);
+ case 38: return new Case_Group(this, this, 38, inst);
+ case 39: return new IfExp_Group(this, this, 39, inst);
+ case 40: return new CondBlock_Group(this, this, 40, inst);
+ case 41: return new IdRef_ValAssignment(this, this, 41, inst);
+ case 42: return new Id_NameAssignment(this, this, 42, inst);
+ case 43: return new Property_Alternatives(this, this, 43, inst);
+ case 44: return new Variable_Alternatives(this, this, 44, inst);
+ case 45: return new AssignableArray_Group(this, this, 45, inst);
+ case 46: return new AssignableArgList_Group(this, this, 46, inst);
+ case 47: return new AssignableArg_Group(this, this, 47, inst);
+ case 48: return new Assignable_Alternatives(this, this, 48, inst);
+ case 49: return new Arg_Group(this, this, 49, inst);
+ case 50: return new ArgLine_Group(this, this, 50, inst);
+ case 51: return new ExplicitArgList_Group(this, this, 51, inst);
+ case 52: return new ArgList_Group(this, this, 52, inst);
+ case 53: return new Array_Group(this, this, 53, inst);
+ case 54: return new Dictionary_Group(this, this, 54, inst);
+ case 55: return new DictItems_Group(this, this, 55, inst);
+ case 56: return new ExplicitDictItems_Group(this, this, 56, inst);
+ case 57: return new DictLine_Group(this, this, 57, inst);
+ case 58: return new DictItem_Group(this, this, 58, inst);
+ case 59: return new DictKey_Alternatives(this, this, 59, inst);
+ case 60: return new Lambda_Group(this, this, 60, inst);
+ case 61: return new Param_Group(this, this, 61, inst);
+ case 62: return new NumberLiteral_Group(this, this, 62, inst);
+ case 63: return new StringLiteral_Group(this, this, 63, inst);
+ case 64: return new BoolLiteral_Group(this, this, 64, inst);
+ case 65: return new JSLiteral_Group(this, this, 65, inst);
+ case 66: return new RegexLiteral_Group(this, this, 66, inst);
+ case 67: return new Literal_Alternatives(this, this, 67, inst);
+ case 68: return new Parenthetical_Alternatives(this, this, 68, inst);
+ default: return null;
+ }
+ }
+}
+
+
+/************ begin Rule Cakefile ****************
+ *
+ * Cakefile:
+ * tasks+=TaskDeclaration*;
+ *
+ **/
+
+// tasks+=TaskDeclaration*
+protected class Cakefile_TasksAssignment extends AssignmentToken {
+
+ public Cakefile_TasksAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCakefileAccess().getTasksAssignment();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("tasks",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("tasks");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getTaskDeclarationRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCakefileAccess().getTasksTaskDeclarationParserRuleCall_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Cakefile_TasksAssignment(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index - 1, consumed);
+ }
+ }
+}
+
+/************ end Rule Cakefile ****************/
+
+
+/************ begin Rule TaskDeclaration ****************
+ *
+ * / **
+ * * This grammar may look a bit weird. It accepts two kinds of task declaration:
+ * * - task "foo", "Just foo", -> ...
+ * * - task "foo", "Just foo", (opts) -> ...
+ * *
+ * * They are actually calls of the "task" function with a lambda as its last argument.
+ * * The lambda has no parameter in the first case, and a single parameter ("opts") in the second case.
+ * * So the lexer inserts extra parens
+ * * (CALL_START and CALL_END tokens) to make it a function call.
+ * * / TaskDeclaration:
+ * TASK CALL_START name=StringLiteral COMMA description=StringLiteral COMMA (PARAM_START options=Id PARAM_END)?
+ * FUNC_ARROW body=Block CALL_END TERMINATOR;
+ *
+ **/
+
+// TASK CALL_START name=StringLiteral COMMA description=StringLiteral COMMA (PARAM_START options=Id PARAM_END)? FUNC_ARROW
+// body=Block CALL_END TERMINATOR
+protected class TaskDeclaration_Group extends GroupToken {
+
+ public TaskDeclaration_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_TERMINATORTerminalRuleCall_10(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getTaskDeclarationRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// TASK
+protected class TaskDeclaration_TASKTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public TaskDeclaration_TASKTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getTASKTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// CALL_START
+protected class TaskDeclaration_CALL_STARTTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public TaskDeclaration_CALL_STARTTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getCALL_STARTTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_TASKTerminalRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// name=StringLiteral
+protected class TaskDeclaration_NameAssignment_2 extends AssignmentToken {
+
+ public TaskDeclaration_NameAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getNameAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new StringLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getStringLiteralRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getTaskDeclarationAccess().getNameStringLiteralParserRuleCall_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new TaskDeclaration_CALL_STARTTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// COMMA
+protected class TaskDeclaration_COMMATerminalRuleCall_3 extends UnassignedTextToken {
+
+ public TaskDeclaration_COMMATerminalRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_NameAssignment_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// description=StringLiteral
+protected class TaskDeclaration_DescriptionAssignment_4 extends AssignmentToken {
+
+ public TaskDeclaration_DescriptionAssignment_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getDescriptionAssignment_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new StringLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("description",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("description");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getStringLiteralRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getTaskDeclarationAccess().getDescriptionStringLiteralParserRuleCall_4_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new TaskDeclaration_COMMATerminalRuleCall_3(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// COMMA
+protected class TaskDeclaration_COMMATerminalRuleCall_5 extends UnassignedTextToken {
+
+ public TaskDeclaration_COMMATerminalRuleCall_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_5();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_DescriptionAssignment_4(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// (PARAM_START options=Id PARAM_END)?
+protected class TaskDeclaration_Group_6 extends GroupToken {
+
+ public TaskDeclaration_Group_6(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getGroup_6();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_PARAM_ENDTerminalRuleCall_6_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// PARAM_START
+protected class TaskDeclaration_PARAM_STARTTerminalRuleCall_6_0 extends UnassignedTextToken {
+
+ public TaskDeclaration_PARAM_STARTTerminalRuleCall_6_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getPARAM_STARTTerminalRuleCall_6_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_COMMATerminalRuleCall_5(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// options=Id
+protected class TaskDeclaration_OptionsAssignment_6_1 extends AssignmentToken {
+
+ public TaskDeclaration_OptionsAssignment_6_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getOptionsAssignment_6_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("options",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("options");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getTaskDeclarationAccess().getOptionsIdParserRuleCall_6_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new TaskDeclaration_PARAM_STARTTerminalRuleCall_6_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// PARAM_END
+protected class TaskDeclaration_PARAM_ENDTerminalRuleCall_6_2 extends UnassignedTextToken {
+
+ public TaskDeclaration_PARAM_ENDTerminalRuleCall_6_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getPARAM_ENDTerminalRuleCall_6_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_OptionsAssignment_6_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+// FUNC_ARROW
+protected class TaskDeclaration_FUNC_ARROWTerminalRuleCall_7 extends UnassignedTextToken {
+
+ public TaskDeclaration_FUNC_ARROWTerminalRuleCall_7(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getFUNC_ARROWTerminalRuleCall_7();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_Group_6(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new TaskDeclaration_COMMATerminalRuleCall_5(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// body=Block
+protected class TaskDeclaration_BodyAssignment_8 extends AssignmentToken {
+
+ public TaskDeclaration_BodyAssignment_8(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getBodyAssignment_8();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getTaskDeclarationAccess().getBodyBlockParserRuleCall_8_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new TaskDeclaration_FUNC_ARROWTerminalRuleCall_7(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// CALL_END
+protected class TaskDeclaration_CALL_ENDTerminalRuleCall_9 extends UnassignedTextToken {
+
+ public TaskDeclaration_CALL_ENDTerminalRuleCall_9(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getCALL_ENDTerminalRuleCall_9();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_BodyAssignment_8(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR
+protected class TaskDeclaration_TERMINATORTerminalRuleCall_10 extends UnassignedTextToken {
+
+ public TaskDeclaration_TERMINATORTerminalRuleCall_10(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getTaskDeclarationAccess().getTERMINATORTerminalRuleCall_10();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new TaskDeclaration_CALL_ENDTerminalRuleCall_9(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule TaskDeclaration ****************/
+
+
+/************ begin Rule Root ****************
+ *
+ * Root:
+ * (Body | Block TERMINATOR)?;
+ *
+ **/
+
+// (Body | Block TERMINATOR)?
+protected class Root_Alternatives extends AlternativesToken {
+
+ public Root_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getRootAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Root_BodyParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Root_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBlockAccess().getBlockAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getBodyRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Body
+protected class Root_BodyParserRuleCall_0 extends RuleCallToken {
+
+ public Root_BodyParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRootAccess().getBodyParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBodyRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Body_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Block TERMINATOR
+protected class Root_Group_1 extends GroupToken {
+
+ public Root_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRootAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Root_TERMINATORTerminalRuleCall_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// Block
+protected class Root_BlockParserRuleCall_1_0 extends RuleCallToken {
+
+ public Root_BlockParserRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRootAccess().getBlockParserRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Block_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// TERMINATOR
+protected class Root_TERMINATORTerminalRuleCall_1_1 extends UnassignedTextToken {
+
+ public Root_TERMINATORTerminalRuleCall_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRootAccess().getTERMINATORTerminalRuleCall_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Root_BlockParserRuleCall_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+/************ end Rule Root ****************/
+
+
+/************ begin Rule Body ****************
+ *
+ * Body:
+ * lines+=Line (TERMINATOR lines+=Line?)*;
+ *
+ **/
+
+// lines+=Line (TERMINATOR lines+=Line?)*
+protected class Body_Group extends GroupToken {
+
+ public Body_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getBodyAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Body_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBodyRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// lines+=Line
+protected class Body_LinesAssignment_0 extends AssignmentToken {
+
+ public Body_LinesAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getBodyAccess().getLinesAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Line_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (TERMINATOR lines+=Line?)*
+protected class Body_Group_1 extends GroupToken {
+
+ public Body_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getBodyAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_LinesAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR
+protected class Body_TERMINATORTerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public Body_TERMINATORTerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Body_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=Line?
+protected class Body_LinesAssignment_1_1 extends AssignmentToken {
+
+ public Body_LinesAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getBodyAccess().getLinesAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Line_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Body_TERMINATORTerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule Body ****************/
+
+
+/************ begin Rule Line ****************
+ *
+ * Line:
+ * Stmt | Expression;
+ *
+ **/
+
+// Stmt | Expression
+protected class Line_Alternatives extends AlternativesToken {
+
+ public Line_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getLineAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Line_StmtParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Line_ExpressionParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Stmt
+protected class Line_StmtParserRuleCall_0 extends RuleCallToken {
+
+ public Line_StmtParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLineAccess().getStmtParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Stmt_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Stmt_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Expression
+protected class Line_ExpressionParserRuleCall_1 extends RuleCallToken {
+
+ public Line_ExpressionParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLineAccess().getExpressionParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Expression_PostfixParserRuleCall.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Line ****************/
+
+
+/************ begin Rule Stmt ****************
+ *
+ * Stmt:
+ * ReturnStmt | ThrowStmt | RequireStmt | Comment | ClassDeclaration | statement=STATEMENT;
+ *
+ **/
+
+// ReturnStmt | ThrowStmt | RequireStmt | Comment | ClassDeclaration | statement=STATEMENT
+protected class Stmt_Alternatives extends AlternativesToken {
+
+ public Stmt_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getStmtAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Stmt_ReturnStmtParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Stmt_ThrowStmtParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Stmt_RequireStmtParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new Stmt_CommentParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
+ case 4: return new Stmt_ClassDeclarationParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
+ case 5: return new Stmt_StatementAssignment_5(lastRuleCallOrigin, this, 5, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStmtRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// ReturnStmt
+protected class Stmt_ReturnStmtParserRuleCall_0 extends RuleCallToken {
+
+ public Stmt_ReturnStmtParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ReturnStmt_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// ThrowStmt
+protected class Stmt_ThrowStmtParserRuleCall_1 extends RuleCallToken {
+
+ public Stmt_ThrowStmtParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThrowStmt_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ThrowStmt_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// RequireStmt
+protected class Stmt_RequireStmtParserRuleCall_2 extends RuleCallToken {
+
+ public Stmt_RequireStmtParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(RequireStmt_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Comment
+protected class Stmt_CommentParserRuleCall_3 extends RuleCallToken {
+
+ public Stmt_CommentParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getCommentParserRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Comment_CommentAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Comment_CommentAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// ClassDeclaration
+protected class Stmt_ClassDeclarationParserRuleCall_4 extends RuleCallToken {
+
+ public Stmt_ClassDeclarationParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ClassDeclaration_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// statement=STATEMENT
+protected class Stmt_StatementAssignment_5 extends AssignmentToken {
+
+ public Stmt_StatementAssignment_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getStmtAccess().getStatementAssignment_5();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getStmtRule().getType().getClassifier())
+ return null;
+ if((value = eObjectConsumer.getConsumable("statement",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("statement");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+/************ end Rule Stmt ****************/
+
+
+/************ begin Rule Comment ****************
+ *
+ * Comment:
+ * comment=HERECOMMENT;
+ *
+ **/
+
+// comment=HERECOMMENT
+protected class Comment_CommentAssignment extends AssignmentToken {
+
+ public Comment_CommentAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCommentAccess().getCommentAssignment();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCommentRule().getType().getClassifier())
+ return null;
+ if((value = eObjectConsumer.getConsumable("comment",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("comment");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+/************ end Rule Comment ****************/
+
+
+/************ begin Rule RequireStmt ****************
+ *
+ * / **
+ * * Treat it a special way, because it takes care of import
+ * * / RequireStmt:
+ * => (importedNamespace=Id EQUAL "require") CALL_START uri=STRING CALL_END;
+ *
+ **/
+
+// => (importedNamespace=Id EQUAL "require") CALL_START uri=STRING CALL_END
+protected class RequireStmt_Group extends GroupToken {
+
+ public RequireStmt_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_CALL_ENDTerminalRuleCall_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRequireStmtRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (importedNamespace=Id EQUAL "require")
+protected class RequireStmt_Group_0 extends GroupToken {
+
+ public RequireStmt_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_Group_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// importedNamespace=Id EQUAL "require"
+protected class RequireStmt_Group_0_0 extends GroupToken {
+
+ public RequireStmt_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_RequireKeyword_0_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// importedNamespace=Id
+protected class RequireStmt_ImportedNamespaceAssignment_0_0_0 extends AssignmentToken {
+
+ public RequireStmt_ImportedNamespaceAssignment_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getImportedNamespaceAssignment_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("importedNamespace",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("importedNamespace");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// EQUAL
+protected class RequireStmt_EQUALTerminalRuleCall_0_0_1 extends UnassignedTextToken {
+
+ public RequireStmt_EQUALTerminalRuleCall_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_ImportedNamespaceAssignment_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// "require"
+protected class RequireStmt_RequireKeyword_0_0_2 extends KeywordToken {
+
+ public RequireStmt_RequireKeyword_0_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Keyword getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_EQUALTerminalRuleCall_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+// CALL_START
+protected class RequireStmt_CALL_STARTTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public RequireStmt_CALL_STARTTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_Group_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// uri=STRING
+protected class RequireStmt_UriAssignment_2 extends AssignmentToken {
+
+ public RequireStmt_UriAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getUriAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_CALL_STARTTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("uri",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("uri");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// CALL_END
+protected class RequireStmt_CALL_ENDTerminalRuleCall_3 extends UnassignedTextToken {
+
+ public RequireStmt_CALL_ENDTerminalRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RequireStmt_UriAssignment_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule RequireStmt ****************/
+
+
+/************ begin Rule ReturnStmt ****************
+ *
+ * ReturnStmt:
+ * {ReturnStmt} RETURN expression=Expression? (POST_IF condition=Expression)?;
+ *
+ **/
+
+// {ReturnStmt} RETURN expression=Expression? (POST_IF condition=Expression)?
+protected class ReturnStmt_Group extends GroupToken {
+
+ public ReturnStmt_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_Group_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ReturnStmt_ExpressionAssignment_2(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new ReturnStmt_RETURNTerminalRuleCall_1(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getReturnStmtAccess().getReturnStmtAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ReturnStmt}
+protected class ReturnStmt_ReturnStmtAction_0 extends ActionToken {
+
+ public ReturnStmt_ReturnStmtAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getReturnStmtAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// RETURN
+protected class ReturnStmt_RETURNTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public ReturnStmt_RETURNTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_ReturnStmtAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// expression=Expression?
+protected class ReturnStmt_ExpressionAssignment_2 extends AssignmentToken {
+
+ public ReturnStmt_ExpressionAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getExpressionAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("expression",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("expression");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ReturnStmt_RETURNTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (POST_IF condition=Expression)?
+protected class ReturnStmt_Group_3 extends GroupToken {
+
+ public ReturnStmt_Group_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getGroup_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_ConditionAssignment_3_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// POST_IF
+protected class ReturnStmt_POST_IFTerminalRuleCall_3_0 extends UnassignedTextToken {
+
+ public ReturnStmt_POST_IFTerminalRuleCall_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ReturnStmt_ExpressionAssignment_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ReturnStmt_RETURNTerminalRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// condition=Expression
+protected class ReturnStmt_ConditionAssignment_3_1 extends AssignmentToken {
+
+ public ReturnStmt_ConditionAssignment_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getReturnStmtAccess().getConditionAssignment_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("condition",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("condition");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ReturnStmt_POST_IFTerminalRuleCall_3_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule ReturnStmt ****************/
+
+
+/************ begin Rule ThrowStmt ****************
+ *
+ * ThrowStmt:
+ * THROW exp=Expression;
+ *
+ **/
+
+// THROW exp=Expression
+protected class ThrowStmt_Group extends GroupToken {
+
+ public ThrowStmt_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getThrowStmtAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThrowStmt_ExpAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getThrowStmtRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// THROW
+protected class ThrowStmt_THROWTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public ThrowStmt_THROWTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// exp=Expression
+protected class ThrowStmt_ExpAssignment_1 extends AssignmentToken {
+
+ public ThrowStmt_ExpAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getThrowStmtAccess().getExpAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exp",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exp");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ThrowStmt_THROWTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule ThrowStmt ****************/
+
+
+/************ begin Rule SuperClass ****************
+ *
+ * / **
+ * * Coffeescript is permissive, it can be any expression, but we want to be able to check it as crossref
+ * * / SuperClass:
+ * IdRef | Property;
+ *
+ **/
+
+// IdRef | Property
+protected class SuperClass_Alternatives extends AlternativesToken {
+
+ public SuperClass_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getSuperClassAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_IdRefParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new SuperClass_PropertyParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// IdRef
+protected class SuperClass_IdRefParserRuleCall_0 extends RuleCallToken {
+
+ public SuperClass_IdRefParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IdRef_ValAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(IdRef_ValAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Property
+protected class SuperClass_PropertyParserRuleCall_1 extends RuleCallToken {
+
+ public SuperClass_PropertyParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Property_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule SuperClass ****************/
+
+
+/************ begin Rule ClassDeclaration ****************
+ *
+ * ClassDeclaration:
+ * {ClassDeclaration} CLASS (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS
+ * extend=SuperClass)? body=Block)?;
+ *
+ **/
+
+// {ClassDeclaration} CLASS (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS
+// extend=SuperClass)? body=Block)?
+protected class ClassDeclaration_Group extends GroupToken {
+
+ public ClassDeclaration_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_Alternatives_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ClassDeclaration}
+protected class ClassDeclaration_ClassDeclarationAction_0 extends ActionToken {
+
+ public ClassDeclaration_ClassDeclarationAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// CLASS
+protected class ClassDeclaration_CLASSTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public ClassDeclaration_CLASSTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_ClassDeclarationAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block)?
+protected class ClassDeclaration_Alternatives_2 extends AlternativesToken {
+
+ public ClassDeclaration_Alternatives_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getAlternatives_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_BodyAssignment_2_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ClassDeclaration_Group_2_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new ClassDeclaration_Group_2_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// body=Block
+protected class ClassDeclaration_BodyAssignment_2_0 extends AssignmentToken {
+
+ public ClassDeclaration_BodyAssignment_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// EXTENDS extend=SuperClass body=Block?
+protected class ClassDeclaration_Group_2_1 extends GroupToken {
+
+ public ClassDeclaration_Group_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getGroup_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_BodyAssignment_2_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ClassDeclaration_ExtendAssignment_2_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS
+protected class ClassDeclaration_EXTENDSTerminalRuleCall_2_1_0 extends UnassignedTextToken {
+
+ public ClassDeclaration_EXTENDSTerminalRuleCall_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// extend=SuperClass
+protected class ClassDeclaration_ExtendAssignment_2_1_1 extends AssignmentToken {
+
+ public ClassDeclaration_ExtendAssignment_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("extend",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("extend");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getSuperClassRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_EXTENDSTerminalRuleCall_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// body=Block?
+protected class ClassDeclaration_BodyAssignment_2_1_2 extends AssignmentToken {
+
+ public ClassDeclaration_BodyAssignment_2_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_ExtendAssignment_2_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block
+protected class ClassDeclaration_Group_2_2 extends GroupToken {
+
+ public ClassDeclaration_Group_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getGroup_2_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_BodyAssignment_2_2_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// name=(Id | Property)
+protected class ClassDeclaration_NameAssignment_2_2_0 extends AssignmentToken {
+
+ public ClassDeclaration_NameAssignment_2_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getNameAssignment_2_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ case 1: return new Property_Alternatives(this, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getPropertyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (EXTENDS extend=SuperClass)?
+protected class ClassDeclaration_Group_2_2_1 extends GroupToken {
+
+ public ClassDeclaration_Group_2_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getGroup_2_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_ExtendAssignment_2_2_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS
+protected class ClassDeclaration_EXTENDSTerminalRuleCall_2_2_1_0 extends UnassignedTextToken {
+
+ public ClassDeclaration_EXTENDSTerminalRuleCall_2_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ClassDeclaration_NameAssignment_2_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// extend=SuperClass
+protected class ClassDeclaration_ExtendAssignment_2_2_1_1 extends AssignmentToken {
+
+ public ClassDeclaration_ExtendAssignment_2_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getExtendAssignment_2_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("extend",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("extend");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getSuperClassRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_EXTENDSTerminalRuleCall_2_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// body=Block
+protected class ClassDeclaration_BodyAssignment_2_2_2 extends AssignmentToken {
+
+ public ClassDeclaration_BodyAssignment_2_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getClassDeclarationAccess().getBodyAssignment_2_2_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ClassDeclaration_Group_2_2_1(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new ClassDeclaration_NameAssignment_2_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+/************ end Rule ClassDeclaration ****************/
+
+
+/************ begin Rule AssignedClassDeclaration ****************
+ *
+ * / **
+ * * FIXME: it should be the same as ClassDeclaration, but it would result in a non-LL decision,
+ * * so I just removed the problematic options (a class body and a name or a superclass is required).
+ * * / AssignedClassDeclaration:
+ * {ClassDeclaration} CLASS (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)?
+ * body=Block)?;
+ *
+ **/
+
+// {ClassDeclaration} CLASS (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)?
+// body=Block)?
+protected class AssignedClassDeclaration_Group extends GroupToken {
+
+ public AssignedClassDeclaration_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_Alternatives_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignedClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ClassDeclaration}
+protected class AssignedClassDeclaration_ClassDeclarationAction_0 extends ActionToken {
+
+ public AssignedClassDeclaration_ClassDeclarationAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// CLASS
+protected class AssignedClassDeclaration_CLASSTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public AssignedClassDeclaration_CLASSTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_ClassDeclarationAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block)?
+protected class AssignedClassDeclaration_Alternatives_2 extends AlternativesToken {
+
+ public AssignedClassDeclaration_Alternatives_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getAlternatives_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_Group_2_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignedClassDeclaration_Group_2_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS extend=SuperClass body=Block
+protected class AssignedClassDeclaration_Group_2_0 extends GroupToken {
+
+ public AssignedClassDeclaration_Group_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_BodyAssignment_2_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS
+protected class AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_0_0 extends UnassignedTextToken {
+
+ public AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// extend=SuperClass
+protected class AssignedClassDeclaration_ExtendAssignment_2_0_1 extends AssignmentToken {
+
+ public AssignedClassDeclaration_ExtendAssignment_2_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("extend",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("extend");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getSuperClassRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// body=Block
+protected class AssignedClassDeclaration_BodyAssignment_2_0_2 extends AssignmentToken {
+
+ public AssignedClassDeclaration_BodyAssignment_2_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_ExtendAssignment_2_0_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// name=(Id | Property) (EXTENDS extend=SuperClass)? body=Block
+protected class AssignedClassDeclaration_Group_2_1 extends GroupToken {
+
+ public AssignedClassDeclaration_Group_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_BodyAssignment_2_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// name=(Id | Property)
+protected class AssignedClassDeclaration_NameAssignment_2_1_0 extends AssignmentToken {
+
+ public AssignedClassDeclaration_NameAssignment_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getNameAssignment_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ case 1: return new Property_Alternatives(this, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getPropertyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_CLASSTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (EXTENDS extend=SuperClass)?
+protected class AssignedClassDeclaration_Group_2_1_1 extends GroupToken {
+
+ public AssignedClassDeclaration_Group_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getGroup_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_ExtendAssignment_2_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EXTENDS
+protected class AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_1_1_0 extends UnassignedTextToken {
+
+ public AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_NameAssignment_2_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// extend=SuperClass
+protected class AssignedClassDeclaration_ExtendAssignment_2_1_1_1 extends AssignmentToken {
+
+ public AssignedClassDeclaration_ExtendAssignment_2_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getExtendAssignment_2_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new SuperClass_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("extend",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("extend");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getSuperClassRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_EXTENDSTerminalRuleCall_2_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// body=Block
+protected class AssignedClassDeclaration_BodyAssignment_2_1_2 extends AssignmentToken {
+
+ public AssignedClassDeclaration_BodyAssignment_2_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignedClassDeclarationAccess().getBodyAssignment_2_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_Group_2_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new AssignedClassDeclaration_NameAssignment_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+/************ end Rule AssignedClassDeclaration ****************/
+
+
+/************ begin Rule Expression ****************
+ *
+ * Expression:
+ * Postfix;
+ *
+ **/
+
+// Postfix
+protected class Expression_PostfixParserRuleCall extends RuleCallToken {
+
+ public Expression_PostfixParserRuleCall(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExpressionAccess().getPostfixParserRuleCall();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Postfix_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+/************ end Rule Expression ****************/
+
+
+/************ begin Rule Postfix ****************
+ *
+ * // right-assoc
+ * // Note: the lexer seems to know it should give a POST_IF token here
+ * Postfix returns Expression: //Assignment postfix+=(PostfixIf | ForBody)?;
+ * Assignment (POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE
+ * {While.dummy=current} body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN
+ * when=Expression)?)?;
+ *
+ **/
+
+// //Assignment postfix+=(PostfixIf | ForBody)?;
+// Assignment (POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE
+// {While.dummy=current} body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN
+// when=Expression)?)?
+protected class Postfix_Group extends GroupToken {
+
+ public Postfix_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// //Assignment postfix+=(PostfixIf | ForBody)?;
+// Assignment
+protected class Postfix_AssignmentParserRuleCall_0 extends RuleCallToken {
+
+ public Postfix_AssignmentParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Assignment_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE {While.dummy=current}
+// body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN when=Expression)?)?
+protected class Postfix_Alternatives_1 extends AlternativesToken {
+
+ public Postfix_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Group_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Postfix_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Postfix_Group_1_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new Postfix_Group_1_3(lastRuleCallOrigin, this, 3, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => POST_IF {If.dummy=current} condition=Expression
+protected class Postfix_Group_1_0 extends GroupToken {
+
+ public Postfix_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_ConditionAssignment_1_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => POST_IF
+protected class Postfix_POST_IFTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public Postfix_POST_IFTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {If.dummy=current}
+protected class Postfix_IfDummyAction_1_0_1 extends ActionToken {
+
+ public Postfix_IfDummyAction_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_POST_IFTerminalRuleCall_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("dummy", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("dummy")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// condition=Expression
+protected class Postfix_ConditionAssignment_1_0_2 extends AssignmentToken {
+
+ public Postfix_ConditionAssignment_1_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getConditionAssignment_1_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("condition",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("condition");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_IfDummyAction_1_0_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// => FOR {For.dummy=current} body=ForBody
+protected class Postfix_Group_1_1 extends GroupToken {
+
+ public Postfix_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_BodyAssignment_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => FOR
+protected class Postfix_FORTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public Postfix_FORTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {For.dummy=current}
+protected class Postfix_ForDummyAction_1_1_1 extends ActionToken {
+
+ public Postfix_ForDummyAction_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getForDummyAction_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_FORTerminalRuleCall_1_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("dummy", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("dummy")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// body=ForBody
+protected class Postfix_BodyAssignment_1_1_2 extends AssignmentToken {
+
+ public Postfix_BodyAssignment_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getBodyAssignment_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForBodyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_ForDummyAction_1_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// => WHILE {While.dummy=current} body=Expression (WHEN when=Expression)?
+protected class Postfix_Group_1_2 extends GroupToken {
+
+ public Postfix_Group_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Group_1_2_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Postfix_BodyAssignment_1_2_2(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => WHILE
+protected class Postfix_WHILETerminalRuleCall_1_2_0 extends UnassignedTextToken {
+
+ public Postfix_WHILETerminalRuleCall_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {While.dummy=current}
+protected class Postfix_WhileDummyAction_1_2_1 extends ActionToken {
+
+ public Postfix_WhileDummyAction_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_WHILETerminalRuleCall_1_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("dummy", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("dummy")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// body=Expression
+protected class Postfix_BodyAssignment_1_2_2 extends AssignmentToken {
+
+ public Postfix_BodyAssignment_1_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getBodyAssignment_1_2_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_WhileDummyAction_1_2_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression)?
+protected class Postfix_Group_1_2_3 extends GroupToken {
+
+ public Postfix_Group_1_2_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_2_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_WhenAssignment_1_2_3_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class Postfix_WHENTerminalRuleCall_1_2_3_0 extends UnassignedTextToken {
+
+ public Postfix_WHENTerminalRuleCall_1_2_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_BodyAssignment_1_2_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class Postfix_WhenAssignment_1_2_3_1 extends AssignmentToken {
+
+ public Postfix_WhenAssignment_1_2_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWhenAssignment_1_2_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_WHENTerminalRuleCall_1_2_3_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// => UNTIL {Until.dummy=current} body=Expression (WHEN when=Expression)?
+protected class Postfix_Group_1_3 extends GroupToken {
+
+ public Postfix_Group_1_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_Group_1_3_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Postfix_BodyAssignment_1_3_2(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => UNTIL
+protected class Postfix_UNTILTerminalRuleCall_1_3_0 extends UnassignedTextToken {
+
+ public Postfix_UNTILTerminalRuleCall_1_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_AssignmentParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {Until.dummy=current}
+protected class Postfix_UntilDummyAction_1_3_1 extends ActionToken {
+
+ public Postfix_UntilDummyAction_1_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_UNTILTerminalRuleCall_1_3_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("dummy", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("dummy")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// body=Expression
+protected class Postfix_BodyAssignment_1_3_2 extends AssignmentToken {
+
+ public Postfix_BodyAssignment_1_3_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getBodyAssignment_1_3_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_UntilDummyAction_1_3_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression)?
+protected class Postfix_Group_1_3_3 extends GroupToken {
+
+ public Postfix_Group_1_3_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getGroup_1_3_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_WhenAssignment_1_3_3_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class Postfix_WHENTerminalRuleCall_1_3_3_0 extends UnassignedTextToken {
+
+ public Postfix_WHENTerminalRuleCall_1_3_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Postfix_BodyAssignment_1_3_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class Postfix_WhenAssignment_1_3_3_1 extends AssignmentToken {
+
+ public Postfix_WhenAssignment_1_3_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPostfixAccess().getWhenAssignment_1_3_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Postfix_WHENTerminalRuleCall_1_3_3_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+
+/************ end Rule Postfix ****************/
+
+
+/************ begin Rule ForBody ****************
+ *
+ * ForBody returns Expression: //FIXME: Range |
+ * OWN? indexes+=ForValue (COMMA indexes+=ForValue)* source=ForSource;
+ *
+ **/
+
+// //FIXME: Range |
+// OWN? indexes+=ForValue (COMMA indexes+=ForValue)* source=ForSource
+protected class ForBody_Group extends GroupToken {
+
+ public ForBody_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_SourceAssignment_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getForBodyRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// indexes+=ForValue
+protected class ForBody_IndexesAssignment_1 extends AssignmentToken {
+
+ public ForBody_IndexesAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getIndexesAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForValue_IdParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("indexes",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("indexes");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForValueRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (COMMA indexes+=ForValue)*
+protected class ForBody_Group_2 extends GroupToken {
+
+ public ForBody_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_IndexesAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class ForBody_COMMATerminalRuleCall_2_0 extends UnassignedTextToken {
+
+ public ForBody_COMMATerminalRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_Group_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForBody_IndexesAssignment_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// indexes+=ForValue
+protected class ForBody_IndexesAssignment_2_1 extends AssignmentToken {
+
+ public ForBody_IndexesAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getIndexesAssignment_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForValue_IdParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("indexes",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("indexes");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForValueRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForBody_COMMATerminalRuleCall_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// source=ForSource
+protected class ForBody_SourceAssignment_3 extends AssignmentToken {
+
+ public ForBody_SourceAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForBodyAccess().getSourceAssignment_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForSourceRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForBody_Group_2(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new ForBody_IndexesAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule ForBody ****************/
+
+
+/************ begin Rule ForValue ****************
+ *
+ * //FIXME | Array | Dictionary;
+ * ForValue:
+ * Id;
+ *
+ **/
+
+// Id
+protected class ForValue_IdParserRuleCall extends RuleCallToken {
+
+ public ForValue_IdParserRuleCall(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForValueAccess().getIdParserRuleCall();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+/************ end Rule ForValue ****************/
+
+
+/************ begin Rule ForSource ****************
+ *
+ * ForSource:
+ * {ForSource} (FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY
+ * by=Expression)? | BY by=Expression (WHEN when=Expression)?)?);
+ *
+ **/
+
+// {ForSource} (FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY
+// by=Expression)? | BY by=Expression (WHEN when=Expression)?)?)
+protected class ForSource_Group extends GroupToken {
+
+ public ForSource_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getForSourceAccess().getForSourceAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ForSource}
+protected class ForSource_ForSourceAction_0 extends ActionToken {
+
+ public ForSource_ForSourceAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getForSourceAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// => FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY by=Expression)? |
+// BY by=Expression (WHEN when=Expression)?)?
+protected class ForSource_Alternatives_1 extends AlternativesToken {
+
+ public ForSource_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => FOROF source=Expression (WHEN when=Expression)?
+protected class ForSource_Group_1_0 extends GroupToken {
+
+ public ForSource_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_0_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_SourceAssignment_1_0_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => FOROF
+protected class ForSource_FOROFTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public ForSource_FOROFTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_ForSourceAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// source=Expression
+protected class ForSource_SourceAssignment_1_0_1 extends AssignmentToken {
+
+ public ForSource_SourceAssignment_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getSourceAssignment_1_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_FOROFTerminalRuleCall_1_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression)?
+protected class ForSource_Group_1_0_2 extends GroupToken {
+
+ public ForSource_Group_1_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_WhenAssignment_1_0_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class ForSource_WHENTerminalRuleCall_1_0_2_0 extends UnassignedTextToken {
+
+ public ForSource_WHENTerminalRuleCall_1_0_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_SourceAssignment_1_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class ForSource_WhenAssignment_1_0_2_1 extends AssignmentToken {
+
+ public ForSource_WhenAssignment_1_0_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWhenAssignment_1_0_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_WHENTerminalRuleCall_1_0_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// => FORIN source=Expression (WHEN when=Expression (BY by=Expression)? | BY by=Expression (WHEN when=Expression)?)?
+protected class ForSource_Group_1_1 extends GroupToken {
+
+ public ForSource_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Alternatives_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_SourceAssignment_1_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => FORIN
+protected class ForSource_FORINTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public ForSource_FORINTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_ForSourceAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// source=Expression
+protected class ForSource_SourceAssignment_1_1_1 extends AssignmentToken {
+
+ public ForSource_SourceAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getSourceAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_FORINTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression (BY by=Expression)? | BY by=Expression (WHEN when=Expression)?)?
+protected class ForSource_Alternatives_1_1_2 extends AlternativesToken {
+
+ public ForSource_Alternatives_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getAlternatives_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_1_2_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_Group_1_1_2_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN when=Expression (BY by=Expression)?
+protected class ForSource_Group_1_1_2_0 extends GroupToken {
+
+ public ForSource_Group_1_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_1_2_0_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_WhenAssignment_1_1_2_0_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class ForSource_WHENTerminalRuleCall_1_1_2_0_0 extends UnassignedTextToken {
+
+ public ForSource_WHENTerminalRuleCall_1_1_2_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_SourceAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class ForSource_WhenAssignment_1_1_2_0_1 extends AssignmentToken {
+
+ public ForSource_WhenAssignment_1_1_2_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_WHENTerminalRuleCall_1_1_2_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> BY by=Expression)?
+protected class ForSource_Group_1_1_2_0_2 extends GroupToken {
+
+ public ForSource_Group_1_1_2_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1_2_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_ByAssignment_1_1_2_0_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => BY
+protected class ForSource_BYTerminalRuleCall_1_1_2_0_2_0 extends UnassignedTextToken {
+
+ public ForSource_BYTerminalRuleCall_1_1_2_0_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_WhenAssignment_1_1_2_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// by=Expression
+protected class ForSource_ByAssignment_1_1_2_0_2_1 extends AssignmentToken {
+
+ public ForSource_ByAssignment_1_1_2_0_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getByAssignment_1_1_2_0_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("by",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("by");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_BYTerminalRuleCall_1_1_2_0_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// => BY by=Expression (WHEN when=Expression)?
+protected class ForSource_Group_1_1_2_1 extends GroupToken {
+
+ public ForSource_Group_1_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_Group_1_1_2_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ForSource_ByAssignment_1_1_2_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => BY
+protected class ForSource_BYTerminalRuleCall_1_1_2_1_0 extends UnassignedTextToken {
+
+ public ForSource_BYTerminalRuleCall_1_1_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_SourceAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// by=Expression
+protected class ForSource_ByAssignment_1_1_2_1_1 extends AssignmentToken {
+
+ public ForSource_ByAssignment_1_1_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getByAssignment_1_1_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("by",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("by");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_BYTerminalRuleCall_1_1_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (=> WHEN when=Expression)?
+protected class ForSource_Group_1_1_2_1_2 extends GroupToken {
+
+ public ForSource_Group_1_1_2_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getGroup_1_1_2_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_WhenAssignment_1_1_2_1_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => WHEN
+protected class ForSource_WHENTerminalRuleCall_1_1_2_1_2_0 extends UnassignedTextToken {
+
+ public ForSource_WHENTerminalRuleCall_1_1_2_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForSource_ByAssignment_1_1_2_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class ForSource_WhenAssignment_1_1_2_1_2_1 extends AssignmentToken {
+
+ public ForSource_WhenAssignment_1_1_2_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getForSourceAccess().getWhenAssignment_1_1_2_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ForSource_WHENTerminalRuleCall_1_1_2_1_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+
+
+
+/************ end Rule ForSource ****************/
+
+
+/************ begin Rule Range ****************
+ *
+ * Range:
+ * => (LBRACKET start=Expression (DOT_DOT | ELLIPSIS)) end=Expression RBRACKET;
+ *
+ **/
+
+// => (LBRACKET start=Expression (DOT_DOT | ELLIPSIS)) end=Expression RBRACKET
+protected class Range_Group extends GroupToken {
+
+ public Range_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRangeAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_RBRACKETTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRangeRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (LBRACKET start=Expression (DOT_DOT | ELLIPSIS))
+protected class Range_Group_0 extends GroupToken {
+
+ public Range_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRangeAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_Group_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LBRACKET start=Expression (DOT_DOT | ELLIPSIS)
+protected class Range_Group_0_0 extends GroupToken {
+
+ public Range_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRangeAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_Alternatives_0_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LBRACKET
+protected class Range_LBRACKETTerminalRuleCall_0_0_0 extends UnassignedTextToken {
+
+ public Range_LBRACKETTerminalRuleCall_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// start=Expression
+protected class Range_StartAssignment_0_0_1 extends AssignmentToken {
+
+ public Range_StartAssignment_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRangeAccess().getStartAssignment_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("start",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("start");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Range_LBRACKETTerminalRuleCall_0_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// DOT_DOT | ELLIPSIS
+protected class Range_Alternatives_0_0_2 extends AlternativesToken {
+
+ public Range_Alternatives_0_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getRangeAccess().getAlternatives_0_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_DOT_DOTTerminalRuleCall_0_0_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// DOT_DOT
+protected class Range_DOT_DOTTerminalRuleCall_0_0_2_0 extends UnassignedTextToken {
+
+ public Range_DOT_DOTTerminalRuleCall_0_0_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_StartAssignment_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+// end=Expression
+protected class Range_EndAssignment_1 extends AssignmentToken {
+
+ public Range_EndAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRangeAccess().getEndAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("end",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("end");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Range_Group_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// RBRACKET
+protected class Range_RBRACKETTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public Range_RBRACKETTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_EndAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule Range ****************/
+
+
+/************ begin Rule Assignment ****************
+ *
+ * Assignment returns Expression:
+ * => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned | LogicOp;
+ *
+ **/
+
+// => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned | LogicOp
+protected class Assignment_Alternatives extends AlternativesToken {
+
+ public Assignment_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Assignment_LogicOpParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned
+protected class Assignment_Group_0 extends GroupToken {
+
+ public Assignment_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_RightAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN))
+protected class Assignment_Group_0_0 extends GroupToken {
+
+ public Assignment_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_Group_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)
+protected class Assignment_Group_0_0_0 extends GroupToken {
+
+ public Assignment_Group_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getGroup_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_OperatorAssignment_0_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// left=Assignable
+protected class Assignment_LeftAssignment_0_0_0_0 extends AssignmentToken {
+
+ public Assignment_LeftAssignment_0_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getLeftAssignment_0_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignable_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("left",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("left");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignableRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// operator=(EQUAL | COMPOUND_ASSIGN)
+protected class Assignment_OperatorAssignment_0_0_0_1 extends AssignmentToken {
+
+ public Assignment_OperatorAssignment_0_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getOperatorAssignment_0_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignment_LeftAssignment_0_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=Assigned
+protected class Assignment_RightAssignment_0_1 extends AssignmentToken {
+
+ public Assignment_RightAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getRightAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignedRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Assignment_Group_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// LogicOp
+protected class Assignment_LogicOpParserRuleCall_1 extends RuleCallToken {
+
+ public Assignment_LogicOpParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(LogicOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Assignment ****************/
+
+
+/************ begin Rule Assigned ****************
+ *
+ * Assigned returns Expression:
+ * Expression | INDENT Expression OUTDENT | AssignedClassDeclaration;
+ *
+ **/
+
+// Expression | INDENT Expression OUTDENT | AssignedClassDeclaration
+protected class Assigned_Alternatives extends AlternativesToken {
+
+ public Assigned_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_ExpressionParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Assigned_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Assigned_AssignedClassDeclarationParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Expression
+protected class Assigned_ExpressionParserRuleCall_0 extends RuleCallToken {
+
+ public Assigned_ExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Expression_PostfixParserRuleCall.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// INDENT Expression OUTDENT
+protected class Assigned_Group_1 extends GroupToken {
+
+ public Assigned_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_OUTDENTTerminalRuleCall_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// INDENT
+protected class Assigned_INDENTTerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public Assigned_INDENTTerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// Expression
+protected class Assigned_ExpressionParserRuleCall_1_1 extends RuleCallToken {
+
+ public Assigned_ExpressionParserRuleCall_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Expression_PostfixParserRuleCall.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_INDENTTerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class Assigned_OUTDENTTerminalRuleCall_1_2 extends UnassignedTextToken {
+
+ public Assigned_OUTDENTTerminalRuleCall_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assigned_ExpressionParserRuleCall_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+// AssignedClassDeclaration
+protected class Assigned_AssignedClassDeclarationParserRuleCall_2 extends RuleCallToken {
+
+ public Assigned_AssignedClassDeclarationParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignedClassDeclaration_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(AssignedClassDeclaration_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Assigned ****************/
+
+
+/************ begin Rule LogicOp ****************
+ *
+ * LogicOp returns Expression:
+ * CompareOp (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*;
+ *
+ **/
+
+// CompareOp (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*
+protected class LogicOp_Group extends GroupToken {
+
+ public LogicOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new LogicOp_CompareOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// CompareOp
+protected class LogicOp_CompareOpParserRuleCall_0 extends RuleCallToken {
+
+ public LogicOp_CompareOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(CompareOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*
+protected class LogicOp_Group_1 extends GroupToken {
+
+ public LogicOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=LOGIC)
+protected class LogicOp_Group_1_0 extends GroupToken {
+
+ public LogicOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=LOGIC
+protected class LogicOp_Group_1_0_0 extends GroupToken {
+
+ public LogicOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class LogicOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public LogicOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new LogicOp_CompareOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=LOGIC
+protected class LogicOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public LogicOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new LogicOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=CompareOp
+protected class LogicOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public LogicOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLogicOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getCompareOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new LogicOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule LogicOp ****************/
+
+
+/************ begin Rule CompareOp ****************
+ *
+ * CompareOp returns Expression:
+ * RelationOp (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*;
+ *
+ **/
+
+// RelationOp (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*
+protected class CompareOp_Group extends GroupToken {
+
+ public CompareOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new CompareOp_RelationOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// RelationOp
+protected class CompareOp_RelationOpParserRuleCall_0 extends RuleCallToken {
+
+ public CompareOp_RelationOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(RelationOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*
+protected class CompareOp_Group_1 extends GroupToken {
+
+ public CompareOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=COMPARE)
+protected class CompareOp_Group_1_0 extends GroupToken {
+
+ public CompareOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=COMPARE
+protected class CompareOp_Group_1_0_0 extends GroupToken {
+
+ public CompareOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class CompareOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public CompareOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new CompareOp_RelationOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=COMPARE
+protected class CompareOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public CompareOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CompareOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=RelationOp
+protected class CompareOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public CompareOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCompareOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getRelationOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new CompareOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule CompareOp ****************/
+
+
+/************ begin Rule RelationOp ****************
+ *
+ * RelationOp returns Expression:
+ * ShiftOp (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*;
+ *
+ **/
+
+// ShiftOp (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*
+protected class RelationOp_Group extends GroupToken {
+
+ public RelationOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new RelationOp_ShiftOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// ShiftOp
+protected class RelationOp_ShiftOpParserRuleCall_0 extends RuleCallToken {
+
+ public RelationOp_ShiftOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(ShiftOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*
+protected class RelationOp_Group_1 extends GroupToken {
+
+ public RelationOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=RELATION)
+protected class RelationOp_Group_1_0 extends GroupToken {
+
+ public RelationOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=RELATION
+protected class RelationOp_Group_1_0_0 extends GroupToken {
+
+ public RelationOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class RelationOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public RelationOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new RelationOp_ShiftOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=RELATION
+protected class RelationOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public RelationOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RelationOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=ShiftOp
+protected class RelationOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public RelationOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getRelationOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getShiftOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new RelationOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule RelationOp ****************/
+
+
+/************ begin Rule ShiftOp ****************
+ *
+ * ShiftOp returns Expression:
+ * AdditiveOp (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*;
+ *
+ **/
+
+// AdditiveOp (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*
+protected class ShiftOp_Group extends GroupToken {
+
+ public ShiftOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ShiftOp_AdditiveOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// AdditiveOp
+protected class ShiftOp_AdditiveOpParserRuleCall_0 extends RuleCallToken {
+
+ public ShiftOp_AdditiveOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(AdditiveOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*
+protected class ShiftOp_Group_1 extends GroupToken {
+
+ public ShiftOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=SHIFT)
+protected class ShiftOp_Group_1_0 extends GroupToken {
+
+ public ShiftOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=SHIFT
+protected class ShiftOp_Group_1_0_0 extends GroupToken {
+
+ public ShiftOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class ShiftOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public ShiftOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ShiftOp_AdditiveOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=SHIFT
+protected class ShiftOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public ShiftOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ShiftOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=AdditiveOp
+protected class ShiftOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public ShiftOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getShiftOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAdditiveOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ShiftOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule ShiftOp ****************/
+
+
+/************ begin Rule AdditiveOp ****************
+ *
+ * AdditiveOp returns Expression:
+ * MathOp (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*;
+ *
+ **/
+
+// MathOp (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*
+protected class AdditiveOp_Group extends GroupToken {
+
+ public AdditiveOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AdditiveOp_MathOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// MathOp
+protected class AdditiveOp_MathOpParserRuleCall_0 extends RuleCallToken {
+
+ public AdditiveOp_MathOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(MathOp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*
+protected class AdditiveOp_Group_1 extends GroupToken {
+
+ public AdditiveOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=(PLUS | MINUS))
+protected class AdditiveOp_Group_1_0 extends GroupToken {
+
+ public AdditiveOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=(PLUS | MINUS)
+protected class AdditiveOp_Group_1_0_0 extends GroupToken {
+
+ public AdditiveOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class AdditiveOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public AdditiveOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AdditiveOp_MathOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=(PLUS | MINUS)
+protected class AdditiveOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public AdditiveOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AdditiveOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=MathOp
+protected class AdditiveOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public AdditiveOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAdditiveOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getMathOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AdditiveOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule AdditiveOp ****************/
+
+
+/************ begin Rule MathOp ****************
+ *
+ * MathOp returns Expression:
+ * UnaryOp (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*;
+ *
+ **/
+
+// UnaryOp (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*
+protected class MathOp_Group extends GroupToken {
+
+ public MathOp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new MathOp_UnaryOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// UnaryOp
+protected class MathOp_UnaryOpParserRuleCall_0 extends RuleCallToken {
+
+ public MathOp_UnaryOpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(UnaryOp_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*
+protected class MathOp_Group_1 extends GroupToken {
+
+ public MathOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => ({BinaryExp.left=current} operator=MATH)
+protected class MathOp_Group_1_0 extends GroupToken {
+
+ public MathOp_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current} operator=MATH
+protected class MathOp_Group_1_0_0 extends GroupToken {
+
+ public MathOp_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_OperatorAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// {BinaryExp.left=current}
+protected class MathOp_BinaryExpLeftAction_1_0_0_0 extends ActionToken {
+
+ public MathOp_BinaryExpLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new MathOp_UnaryOpParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ Object val = eObjectConsumer.getConsumable("left", false);
+ if(val == null) return null;
+ if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
+ return createEObjectConsumer((EObject) val);
+ }
+}
+
+// operator=MATH
+protected class MathOp_OperatorAssignment_1_0_0_1 extends AssignmentToken {
+
+ public MathOp_OperatorAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getOperatorAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new MathOp_BinaryExpLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// right=UnaryOp
+protected class MathOp_RightAssignment_1_1 extends AssignmentToken {
+
+ public MathOp_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getMathOpAccess().getRightAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("right",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getUnaryOpRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new MathOp_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule MathOp ****************/
+
+
+/************ begin Rule UnaryOp ****************
+ *
+ * UnaryOp returns Expression:
+ * (UNARY | PLUS | MINUS) Expression | (PLUS_PLUS | MINUS_MINUS) Variable | // FIXME: postfix increment
+ * Application QUESTION?;
+ *
+ **/
+
+// (UNARY | PLUS | MINUS) Expression | (PLUS_PLUS | MINUS_MINUS) Variable | // FIXME: postfix increment
+// Application QUESTION?
+protected class UnaryOp_Alternatives extends AlternativesToken {
+
+ public UnaryOp_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new UnaryOp_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new UnaryOp_Group_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getAssignmentRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getForDummyAction_1_1_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// (UNARY | PLUS | MINUS) Expression
+protected class UnaryOp_Group_0 extends GroupToken {
+
+ public UnaryOp_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_ExpressionParserRuleCall_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// UNARY | PLUS | MINUS
+protected class UnaryOp_Alternatives_0_0 extends AlternativesToken {
+
+ public UnaryOp_Alternatives_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getAlternatives_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_UNARYTerminalRuleCall_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// UNARY
+protected class UnaryOp_UNARYTerminalRuleCall_0_0_0 extends UnassignedTextToken {
+
+ public UnaryOp_UNARYTerminalRuleCall_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+
+// Expression
+protected class UnaryOp_ExpressionParserRuleCall_0_1 extends RuleCallToken {
+
+ public UnaryOp_ExpressionParserRuleCall_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Expression_PostfixParserRuleCall.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Alternatives_0_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+
+// (PLUS_PLUS | MINUS_MINUS) Variable
+protected class UnaryOp_Group_1 extends GroupToken {
+
+ public UnaryOp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_VariableParserRuleCall_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// PLUS_PLUS | MINUS_MINUS
+protected class UnaryOp_Alternatives_1_0 extends AlternativesToken {
+
+ public UnaryOp_Alternatives_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getAlternatives_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_PLUS_PLUSTerminalRuleCall_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// PLUS_PLUS
+protected class UnaryOp_PLUS_PLUSTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public UnaryOp_PLUS_PLUSTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+
+// Variable
+protected class UnaryOp_VariableParserRuleCall_1_1 extends RuleCallToken {
+
+ public UnaryOp_VariableParserRuleCall_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Variable_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_Alternatives_1_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+
+// // FIXME: postfix increment
+// Application QUESTION?
+protected class UnaryOp_Group_2 extends GroupToken {
+
+ public UnaryOp_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new UnaryOp_ApplicationParserRuleCall_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// // FIXME: postfix increment
+// Application
+protected class UnaryOp_ApplicationParserRuleCall_2_0 extends RuleCallToken {
+
+ public UnaryOp_ApplicationParserRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Application_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+
+/************ end Rule UnaryOp ****************/
+
+
+/************ begin Rule Application ****************
+ *
+ * // Nested function calls and property accesses -- I couldn't come up with a better name
+ * Application:
+ * {SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?) | value=PrimaryExpression features+=FeatureCall*;
+ *
+ **/
+
+// {SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?) | value=PrimaryExpression features+=FeatureCall*
+protected class Application_Alternatives extends AlternativesToken {
+
+ public Application_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Application_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?)
+protected class Application_Group_0 extends GroupToken {
+
+ public Application_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_Group_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationAccess().getSuperCallAction_0_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {SuperCall}
+protected class Application_SuperCallAction_0_0 extends ActionToken {
+
+ public Application_SuperCallAction_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getSuperCallAction_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// SUPER (CALL_START args=ArgList CALL_END)?
+protected class Application_Group_0_1 extends GroupToken {
+
+ public Application_Group_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getGroup_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_Group_0_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Application_SUPERTerminalRuleCall_0_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// SUPER
+protected class Application_SUPERTerminalRuleCall_0_1_0 extends UnassignedTextToken {
+
+ public Application_SUPERTerminalRuleCall_0_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_SuperCallAction_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// (CALL_START args=ArgList CALL_END)?
+protected class Application_Group_0_1_1 extends GroupToken {
+
+ public Application_Group_0_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getGroup_0_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_CALL_ENDTerminalRuleCall_0_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// CALL_START
+protected class Application_CALL_STARTTerminalRuleCall_0_1_1_0 extends UnassignedTextToken {
+
+ public Application_CALL_STARTTerminalRuleCall_0_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_SUPERTerminalRuleCall_0_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// args=ArgList
+protected class Application_ArgsAssignment_0_1_1_1 extends AssignmentToken {
+
+ public Application_ArgsAssignment_0_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getArgsAssignment_0_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("args",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("args");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgListRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Application_CALL_STARTTerminalRuleCall_0_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// CALL_END
+protected class Application_CALL_ENDTerminalRuleCall_0_1_1_2 extends UnassignedTextToken {
+
+ public Application_CALL_ENDTerminalRuleCall_0_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_ArgsAssignment_0_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+// value=PrimaryExpression features+=FeatureCall*
+protected class Application_Group_1 extends GroupToken {
+
+ public Application_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Application_FeaturesAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Application_ValueAssignment_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getApplicationRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// value=PrimaryExpression
+protected class Application_ValueAssignment_1_0 extends AssignmentToken {
+
+ public Application_ValueAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getValueAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("value",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("value");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getPrimaryExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// features+=FeatureCall*
+protected class Application_FeaturesAssignment_1_1 extends AssignmentToken {
+
+ public Application_FeaturesAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getApplicationAccess().getFeaturesAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FeatureCall_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("features",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("features");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getFeatureCallRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Application_FeaturesAssignment_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new Application_ValueAssignment_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule Application ****************/
+
+
+/************ begin Rule FeatureCall ****************
+ *
+ * FeatureCall:
+ * FunctionCall | PropertyAccess;
+ *
+ **/
+
+// FunctionCall | PropertyAccess
+protected class FeatureCall_Alternatives extends AlternativesToken {
+
+ public FeatureCall_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getFeatureCallAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FeatureCall_FunctionCallParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new FeatureCall_PropertyAccessParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getFunctionCallAccess().getFunctionCallAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// FunctionCall
+protected class FeatureCall_FunctionCallParserRuleCall_0 extends RuleCallToken {
+
+ public FeatureCall_FunctionCallParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FunctionCall_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getFunctionCallAccess().getFunctionCallAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(FunctionCall_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// PropertyAccess
+protected class FeatureCall_PropertyAccessParserRuleCall_1 extends RuleCallToken {
+
+ public FeatureCall_PropertyAccessParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PropertyAccess_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(PropertyAccess_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule FeatureCall ****************/
+
+
+/************ begin Rule FunctionCall ****************
+ *
+ * FunctionCall:
+ * {FunctionCall} FUNC_EXIST? CALL_START args=ArgList CALL_END;
+ *
+ **/
+
+// {FunctionCall} FUNC_EXIST? CALL_START args=ArgList CALL_END
+protected class FunctionCall_Group extends GroupToken {
+
+ public FunctionCall_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FunctionCall_CALL_ENDTerminalRuleCall_4(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getFunctionCallAccess().getFunctionCallAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {FunctionCall}
+protected class FunctionCall_FunctionCallAction_0 extends ActionToken {
+
+ public FunctionCall_FunctionCallAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getFunctionCallAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// CALL_START
+protected class FunctionCall_CALL_STARTTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public FunctionCall_CALL_STARTTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FunctionCall_FunctionCallAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// args=ArgList
+protected class FunctionCall_ArgsAssignment_3 extends AssignmentToken {
+
+ public FunctionCall_ArgsAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getArgsAssignment_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("args",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("args");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgListRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new FunctionCall_CALL_STARTTerminalRuleCall_2(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// CALL_END
+protected class FunctionCall_CALL_ENDTerminalRuleCall_4 extends UnassignedTextToken {
+
+ public FunctionCall_CALL_ENDTerminalRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new FunctionCall_ArgsAssignment_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule FunctionCall ****************/
+
+
+/************ begin Rule PropertyAccess ****************
+ *
+ * PropertyAccess:
+ * NamedPropertyAccess | IndexedPropertyAccess;
+ *
+ **/
+
+// NamedPropertyAccess | IndexedPropertyAccess
+protected class PropertyAccess_Alternatives extends AlternativesToken {
+
+ public PropertyAccess_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPropertyAccessAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PropertyAccess_NamedPropertyAccessParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PropertyAccess_IndexedPropertyAccessParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// NamedPropertyAccess
+protected class PropertyAccess_NamedPropertyAccessParserRuleCall_0 extends RuleCallToken {
+
+ public PropertyAccess_NamedPropertyAccessParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NamedPropertyAccess_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(NamedPropertyAccess_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// IndexedPropertyAccess
+protected class PropertyAccess_IndexedPropertyAccessParserRuleCall_1 extends RuleCallToken {
+
+ public PropertyAccess_IndexedPropertyAccessParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IndexedPropertyAccess_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(IndexedPropertyAccess_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule PropertyAccess ****************/
+
+
+/************ begin Rule ThisProperty ****************
+ *
+ * ThisProperty:
+ * AT_SIGIL Id;
+ *
+ **/
+
+// AT_SIGIL Id
+protected class ThisProperty_Group extends GroupToken {
+
+ public ThisProperty_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getThisPropertyAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThisProperty_IdParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// AT_SIGIL
+protected class ThisProperty_AT_SIGILTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public ThisProperty_AT_SIGILTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// Id
+protected class ThisProperty_IdParserRuleCall_1 extends RuleCallToken {
+
+ public ThisProperty_IdParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThisProperty_AT_SIGILTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule ThisProperty ****************/
+
+
+/************ begin Rule NamedPropertyAccess ****************
+ *
+ * NamedPropertyAccess:
+ * accessor=(DOT | QUESTION_DOT) name=Id | accessor=DOUBLE_COLON name=Id?;
+ *
+ **/
+
+// accessor=(DOT | QUESTION_DOT) name=Id | accessor=DOUBLE_COLON name=Id?
+protected class NamedPropertyAccess_Alternatives extends AlternativesToken {
+
+ public NamedPropertyAccess_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NamedPropertyAccess_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new NamedPropertyAccess_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getNamedPropertyAccessRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// accessor=(DOT | QUESTION_DOT) name=Id
+protected class NamedPropertyAccess_Group_0 extends GroupToken {
+
+ public NamedPropertyAccess_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NamedPropertyAccess_NameAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// accessor=(DOT | QUESTION_DOT)
+protected class NamedPropertyAccess_AccessorAssignment_0_0 extends AssignmentToken {
+
+ public NamedPropertyAccess_AccessorAssignment_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("accessor",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("accessor");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// name=Id
+protected class NamedPropertyAccess_NameAssignment_0_1 extends AssignmentToken {
+
+ public NamedPropertyAccess_NameAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new NamedPropertyAccess_AccessorAssignment_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// accessor=DOUBLE_COLON name=Id?
+protected class NamedPropertyAccess_Group_1 extends GroupToken {
+
+ public NamedPropertyAccess_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NamedPropertyAccess_NameAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new NamedPropertyAccess_AccessorAssignment_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// accessor=DOUBLE_COLON
+protected class NamedPropertyAccess_AccessorAssignment_1_0 extends AssignmentToken {
+
+ public NamedPropertyAccess_AccessorAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getAccessorAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("accessor",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("accessor");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// name=Id?
+protected class NamedPropertyAccess_NameAssignment_1_1 extends AssignmentToken {
+
+ public NamedPropertyAccess_NameAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getNamedPropertyAccessAccess().getNameAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("name",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new NamedPropertyAccess_AccessorAssignment_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule NamedPropertyAccess ****************/
+
+
+/************ begin Rule IndexedPropertyAccess ****************
+ *
+ * IndexedPropertyAccess:
+ * INDEX_START index=Index INDEX_END;
+ *
+ **/
+
+// INDEX_START index=Index INDEX_END
+protected class IndexedPropertyAccess_Group extends GroupToken {
+
+ public IndexedPropertyAccess_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexedPropertyAccessAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IndexedPropertyAccess_INDEX_ENDTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexedPropertyAccessRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// INDEX_START
+protected class IndexedPropertyAccess_INDEX_STARTTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public IndexedPropertyAccess_INDEX_STARTTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// index=Index
+protected class IndexedPropertyAccess_IndexAssignment_1 extends AssignmentToken {
+
+ public IndexedPropertyAccess_IndexAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexedPropertyAccessAccess().getIndexAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("index",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("index");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIndexRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new IndexedPropertyAccess_INDEX_STARTTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDEX_END
+protected class IndexedPropertyAccess_INDEX_ENDTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public IndexedPropertyAccess_INDEX_ENDTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IndexedPropertyAccess_IndexAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule IndexedPropertyAccess ****************/
+
+
+/************ begin Rule Index ****************
+ *
+ * Index:
+ * => dots=(DOT_DOT | ELLIPSIS) end=Expression | => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression? |
+ * exp=Expression;
+ *
+ **/
+
+// => dots=(DOT_DOT | ELLIPSIS) end=Expression | => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression? |
+// exp=Expression
+protected class Index_Alternatives extends AlternativesToken {
+
+ public Index_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getIndexAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Index_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Index_ExpAssignment_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIndexRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => dots=(DOT_DOT | ELLIPSIS) end=Expression
+protected class Index_Group_0 extends GroupToken {
+
+ public Index_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_EndAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => dots=(DOT_DOT | ELLIPSIS)
+protected class Index_DotsAssignment_0_0 extends AssignmentToken {
+
+ public Index_DotsAssignment_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getDotsAssignment_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dots",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dots");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// end=Expression
+protected class Index_EndAssignment_0_1 extends AssignmentToken {
+
+ public Index_EndAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getEndAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("end",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("end");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Index_DotsAssignment_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression?
+protected class Index_Group_1 extends GroupToken {
+
+ public Index_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_EndAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Index_Group_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => (start=Expression dots=(DOT_DOT | ELLIPSIS))
+protected class Index_Group_1_0 extends GroupToken {
+
+ public Index_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// start=Expression dots=(DOT_DOT | ELLIPSIS)
+protected class Index_Group_1_0_0 extends GroupToken {
+
+ public Index_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIndexAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_DotsAssignment_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// start=Expression
+protected class Index_StartAssignment_1_0_0_0 extends AssignmentToken {
+
+ public Index_StartAssignment_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getStartAssignment_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("start",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("start");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// dots=(DOT_DOT | ELLIPSIS)
+protected class Index_DotsAssignment_1_0_0_1 extends AssignmentToken {
+
+ public Index_DotsAssignment_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getDotsAssignment_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_StartAssignment_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dots",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dots");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// end=Expression?
+protected class Index_EndAssignment_1_1 extends AssignmentToken {
+
+ public Index_EndAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getEndAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("end",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("end");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Index_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// exp=Expression
+protected class Index_ExpAssignment_2 extends AssignmentToken {
+
+ public Index_ExpAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIndexAccess().getExpAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exp",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exp");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+
+/************ end Rule Index ****************/
+
+
+/************ begin Rule PrimaryExpression ****************
+ *
+ * // Try Range before Array
+ * PrimaryExpression:
+ * IfExp | Parenthetical | Literal | Range | Array | Dictionary | Lambda | ThisProperty | {ThisAlone} THIS | {For} (FOR
+ * loop=ForBody body=Block) | {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block) | {Until} (UNTIL
+ * loop=Expression (WHEN when=Expression)? body=Block) | {Loop} (LOOP body=Block) | {TryCatch} (TRY body=Block (CATCH
+ * exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?) | {Switch} (SWITCH
+ * exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT) | IdRef;
+ *
+ **/
+
+// IfExp | Parenthetical | Literal | Range | Array | Dictionary | Lambda | ThisProperty | {ThisAlone} THIS | {For} (FOR
+// loop=ForBody body=Block) | {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block) | {Until} (UNTIL
+// loop=Expression (WHEN when=Expression)? body=Block) | {Loop} (LOOP body=Block) | {TryCatch} (TRY body=Block (CATCH
+// exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?) | {Switch} (SWITCH
+// exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT) | IdRef
+protected class PrimaryExpression_Alternatives extends AlternativesToken {
+
+ public PrimaryExpression_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_IfExpParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_ParentheticalParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new PrimaryExpression_LiteralParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new PrimaryExpression_RangeParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
+ case 4: return new PrimaryExpression_ArrayParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
+ case 5: return new PrimaryExpression_DictionaryParserRuleCall_5(lastRuleCallOrigin, this, 5, inst);
+ case 6: return new PrimaryExpression_LambdaParserRuleCall_6(lastRuleCallOrigin, this, 6, inst);
+ case 7: return new PrimaryExpression_ThisPropertyParserRuleCall_7(lastRuleCallOrigin, this, 7, inst);
+ case 8: return new PrimaryExpression_Group_8(lastRuleCallOrigin, this, 8, inst);
+ case 9: return new PrimaryExpression_Group_9(lastRuleCallOrigin, this, 9, inst);
+ case 10: return new PrimaryExpression_Group_10(lastRuleCallOrigin, this, 10, inst);
+ case 11: return new PrimaryExpression_Group_11(lastRuleCallOrigin, this, 11, inst);
+ case 12: return new PrimaryExpression_Group_12(lastRuleCallOrigin, this, 12, inst);
+ case 13: return new PrimaryExpression_Group_13(lastRuleCallOrigin, this, 13, inst);
+ case 14: return new PrimaryExpression_Group_14(lastRuleCallOrigin, this, 14, inst);
+ case 15: return new PrimaryExpression_IdRefParserRuleCall_15(lastRuleCallOrigin, this, 15, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getForAction_9_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIfExpRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getLambdaRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getParentheticalRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRangeRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// IfExp
+protected class PrimaryExpression_IfExpParserRuleCall_0 extends RuleCallToken {
+
+ public PrimaryExpression_IfExpParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIfExpRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(IfExp_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Parenthetical
+protected class PrimaryExpression_ParentheticalParserRuleCall_1 extends RuleCallToken {
+
+ public PrimaryExpression_ParentheticalParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getParentheticalRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Parenthetical_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Literal
+protected class PrimaryExpression_LiteralParserRuleCall_2 extends RuleCallToken {
+
+ public PrimaryExpression_LiteralParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Literal_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Literal_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Range
+protected class PrimaryExpression_RangeParserRuleCall_3 extends RuleCallToken {
+
+ public PrimaryExpression_RangeParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Range_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRangeRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Range_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Array
+protected class PrimaryExpression_ArrayParserRuleCall_4 extends RuleCallToken {
+
+ public PrimaryExpression_ArrayParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Array_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Dictionary
+protected class PrimaryExpression_DictionaryParserRuleCall_5 extends RuleCallToken {
+
+ public PrimaryExpression_DictionaryParserRuleCall_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Dictionary_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Lambda
+protected class PrimaryExpression_LambdaParserRuleCall_6 extends RuleCallToken {
+
+ public PrimaryExpression_LambdaParserRuleCall_6(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getLambdaRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Lambda_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// ThisProperty
+protected class PrimaryExpression_ThisPropertyParserRuleCall_7 extends RuleCallToken {
+
+ public PrimaryExpression_ThisPropertyParserRuleCall_7(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThisProperty_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ThisProperty_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// {ThisAlone} THIS
+protected class PrimaryExpression_Group_8 extends GroupToken {
+
+ public PrimaryExpression_Group_8(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_8();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_THISTerminalRuleCall_8_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ThisAlone}
+protected class PrimaryExpression_ThisAloneAction_8_0 extends ActionToken {
+
+ public PrimaryExpression_ThisAloneAction_8_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// THIS
+protected class PrimaryExpression_THISTerminalRuleCall_8_1 extends UnassignedTextToken {
+
+ public PrimaryExpression_THISTerminalRuleCall_8_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_ThisAloneAction_8_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+// {For} (FOR loop=ForBody body=Block)
+protected class PrimaryExpression_Group_9 extends GroupToken {
+
+ public PrimaryExpression_Group_9(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_9();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_9_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getForAction_9_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {For}
+protected class PrimaryExpression_ForAction_9_0 extends ActionToken {
+
+ public PrimaryExpression_ForAction_9_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getForAction_9_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// FOR loop=ForBody body=Block
+protected class PrimaryExpression_Group_9_1 extends GroupToken {
+
+ public PrimaryExpression_Group_9_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_9_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_9_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// FOR
+protected class PrimaryExpression_FORTerminalRuleCall_9_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_FORTerminalRuleCall_9_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_ForAction_9_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// loop=ForBody
+protected class PrimaryExpression_LoopAssignment_9_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_LoopAssignment_9_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_9_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ForBody_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("loop",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("loop");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getForBodyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_FORTerminalRuleCall_9_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_9_1_2 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_9_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_9_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_LoopAssignment_9_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block)
+protected class PrimaryExpression_Group_10 extends GroupToken {
+
+ public PrimaryExpression_Group_10(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_10();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_10_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {While}
+protected class PrimaryExpression_WhileAction_10_0 extends ActionToken {
+
+ public PrimaryExpression_WhileAction_10_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// WHILE loop=Expression (WHEN when=Expression)? body=Block
+protected class PrimaryExpression_Group_10_1 extends GroupToken {
+
+ public PrimaryExpression_Group_10_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_10_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_10_1_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// WHILE
+protected class PrimaryExpression_WHILETerminalRuleCall_10_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_WHILETerminalRuleCall_10_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_WhileAction_10_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// loop=Expression
+protected class PrimaryExpression_LoopAssignment_10_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_LoopAssignment_10_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_10_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("loop",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("loop");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_WHILETerminalRuleCall_10_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (WHEN when=Expression)?
+protected class PrimaryExpression_Group_10_1_2 extends GroupToken {
+
+ public PrimaryExpression_Group_10_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_10_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_WhenAssignment_10_1_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// WHEN
+protected class PrimaryExpression_WHENTerminalRuleCall_10_1_2_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_WHENTerminalRuleCall_10_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_LoopAssignment_10_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class PrimaryExpression_WhenAssignment_10_1_2_1 extends AssignmentToken {
+
+ public PrimaryExpression_WhenAssignment_10_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_10_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_WHENTerminalRuleCall_10_1_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_10_1_3 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_10_1_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_10_1_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_10_1_2(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new PrimaryExpression_LoopAssignment_10_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// {Until} (UNTIL loop=Expression (WHEN when=Expression)? body=Block)
+protected class PrimaryExpression_Group_11 extends GroupToken {
+
+ public PrimaryExpression_Group_11(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_11();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_11_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {Until}
+protected class PrimaryExpression_UntilAction_11_0 extends ActionToken {
+
+ public PrimaryExpression_UntilAction_11_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// UNTIL loop=Expression (WHEN when=Expression)? body=Block
+protected class PrimaryExpression_Group_11_1 extends GroupToken {
+
+ public PrimaryExpression_Group_11_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_11_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_11_1_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// UNTIL
+protected class PrimaryExpression_UNTILTerminalRuleCall_11_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_UNTILTerminalRuleCall_11_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_UntilAction_11_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// loop=Expression
+protected class PrimaryExpression_LoopAssignment_11_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_LoopAssignment_11_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLoopAssignment_11_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("loop",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("loop");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_UNTILTerminalRuleCall_11_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (WHEN when=Expression)?
+protected class PrimaryExpression_Group_11_1_2 extends GroupToken {
+
+ public PrimaryExpression_Group_11_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_11_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_WhenAssignment_11_1_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// WHEN
+protected class PrimaryExpression_WHENTerminalRuleCall_11_1_2_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_WHENTerminalRuleCall_11_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_LoopAssignment_11_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// when=Expression
+protected class PrimaryExpression_WhenAssignment_11_1_2_1 extends AssignmentToken {
+
+ public PrimaryExpression_WhenAssignment_11_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getWhenAssignment_11_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("when",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("when");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_WHENTerminalRuleCall_11_1_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_11_1_3 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_11_1_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_11_1_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_11_1_2(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new PrimaryExpression_LoopAssignment_11_1_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// {Loop} (LOOP body=Block)
+protected class PrimaryExpression_Group_12 extends GroupToken {
+
+ public PrimaryExpression_Group_12(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_12();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_12_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {Loop}
+protected class PrimaryExpression_LoopAction_12_0 extends ActionToken {
+
+ public PrimaryExpression_LoopAction_12_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// LOOP body=Block
+protected class PrimaryExpression_Group_12_1 extends GroupToken {
+
+ public PrimaryExpression_Group_12_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_12_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_12_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LOOP
+protected class PrimaryExpression_LOOPTerminalRuleCall_12_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_LOOPTerminalRuleCall_12_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_LoopAction_12_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_12_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_12_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_12_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_LOOPTerminalRuleCall_12_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// {TryCatch} (TRY body=Block (CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY
+// finallyBlock=Block)?)
+protected class PrimaryExpression_Group_13 extends GroupToken {
+
+ public PrimaryExpression_Group_13(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_13_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {TryCatch}
+protected class PrimaryExpression_TryCatchAction_13_0 extends ActionToken {
+
+ public PrimaryExpression_TryCatchAction_13_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// TRY body=Block (CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?
+protected class PrimaryExpression_Group_13_1 extends GroupToken {
+
+ public PrimaryExpression_Group_13_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Alternatives_13_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_BodyAssignment_13_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TRY
+protected class PrimaryExpression_TRYTerminalRuleCall_13_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_TRYTerminalRuleCall_13_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_TryCatchAction_13_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// body=Block
+protected class PrimaryExpression_BodyAssignment_13_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_BodyAssignment_13_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getBodyAssignment_13_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_TRYTerminalRuleCall_13_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?
+protected class PrimaryExpression_Alternatives_13_1_2 extends AlternativesToken {
+
+ public PrimaryExpression_Alternatives_13_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getAlternatives_13_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_13_1_2_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_Group_13_1_2_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// CATCH exception=Id catchBlock=Block (FINALLY finallyBlock=Block)?
+protected class PrimaryExpression_Group_13_1_2_0 extends GroupToken {
+
+ public PrimaryExpression_Group_13_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_13_1_2_0_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_CatchBlockAssignment_13_1_2_0_2(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// CATCH
+protected class PrimaryExpression_CATCHTerminalRuleCall_13_1_2_0_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_CATCHTerminalRuleCall_13_1_2_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_13_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// exception=Id
+protected class PrimaryExpression_ExceptionAssignment_13_1_2_0_1 extends AssignmentToken {
+
+ public PrimaryExpression_ExceptionAssignment_13_1_2_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getExceptionAssignment_13_1_2_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exception",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exception");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_CATCHTerminalRuleCall_13_1_2_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// catchBlock=Block
+protected class PrimaryExpression_CatchBlockAssignment_13_1_2_0_2 extends AssignmentToken {
+
+ public PrimaryExpression_CatchBlockAssignment_13_1_2_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getCatchBlockAssignment_13_1_2_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("catchBlock",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("catchBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_ExceptionAssignment_13_1_2_0_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (FINALLY finallyBlock=Block)?
+protected class PrimaryExpression_Group_13_1_2_0_3 extends GroupToken {
+
+ public PrimaryExpression_Group_13_1_2_0_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_0_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_FinallyBlockAssignment_13_1_2_0_3_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// FINALLY
+protected class PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_0_3_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_0_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_CatchBlockAssignment_13_1_2_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// finallyBlock=Block
+protected class PrimaryExpression_FinallyBlockAssignment_13_1_2_0_3_1 extends AssignmentToken {
+
+ public PrimaryExpression_FinallyBlockAssignment_13_1_2_0_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_0_3_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("finallyBlock",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("finallyBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_0_3_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// FINALLY finallyBlock=Block
+protected class PrimaryExpression_Group_13_1_2_1 extends GroupToken {
+
+ public PrimaryExpression_Group_13_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_13_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_FinallyBlockAssignment_13_1_2_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// FINALLY
+protected class PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_BodyAssignment_13_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// finallyBlock=Block
+protected class PrimaryExpression_FinallyBlockAssignment_13_1_2_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_FinallyBlockAssignment_13_1_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getFinallyBlockAssignment_13_1_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("finallyBlock",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("finallyBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_FINALLYTerminalRuleCall_13_1_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+
+// {Switch} (SWITCH exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT)
+protected class PrimaryExpression_Group_14 extends GroupToken {
+
+ public PrimaryExpression_Group_14(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_14();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_14_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {Switch}
+protected class PrimaryExpression_SwitchAction_14_0 extends ActionToken {
+
+ public PrimaryExpression_SwitchAction_14_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// SWITCH exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT
+protected class PrimaryExpression_Group_14_1 extends GroupToken {
+
+ public PrimaryExpression_Group_14_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_14_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_OUTDENTTerminalRuleCall_14_1_5(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// SWITCH
+protected class PrimaryExpression_SWITCHTerminalRuleCall_14_1_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_SWITCHTerminalRuleCall_14_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_SwitchAction_14_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// exp=Expression?
+protected class PrimaryExpression_ExpAssignment_14_1_1 extends AssignmentToken {
+
+ public PrimaryExpression_ExpAssignment_14_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getExpAssignment_14_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exp",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exp");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_SWITCHTerminalRuleCall_14_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDENT
+protected class PrimaryExpression_INDENTTerminalRuleCall_14_1_2 extends UnassignedTextToken {
+
+ public PrimaryExpression_INDENTTerminalRuleCall_14_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_ExpAssignment_14_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_SWITCHTerminalRuleCall_14_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// cases+=Case*
+protected class PrimaryExpression_CasesAssignment_14_1_3 extends AssignmentToken {
+
+ public PrimaryExpression_CasesAssignment_14_1_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_14_1_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Case_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("cases",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("cases");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getCaseRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_CasesAssignment_14_1_3(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new PrimaryExpression_INDENTTerminalRuleCall_14_1_2(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (ELSE elseBlock=Block)?
+protected class PrimaryExpression_Group_14_1_4 extends GroupToken {
+
+ public PrimaryExpression_Group_14_1_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getGroup_14_1_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_ElseBlockAssignment_14_1_4_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// ELSE
+protected class PrimaryExpression_ELSETerminalRuleCall_14_1_4_0 extends UnassignedTextToken {
+
+ public PrimaryExpression_ELSETerminalRuleCall_14_1_4_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_CasesAssignment_14_1_3(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_INDENTTerminalRuleCall_14_1_2(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// elseBlock=Block
+protected class PrimaryExpression_ElseBlockAssignment_14_1_4_1 extends AssignmentToken {
+
+ public PrimaryExpression_ElseBlockAssignment_14_1_4_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getElseBlockAssignment_14_1_4_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("elseBlock",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("elseBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new PrimaryExpression_ELSETerminalRuleCall_14_1_4_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// OUTDENT
+protected class PrimaryExpression_OUTDENTTerminalRuleCall_14_1_5 extends UnassignedTextToken {
+
+ public PrimaryExpression_OUTDENTTerminalRuleCall_14_1_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new PrimaryExpression_Group_14_1_4(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new PrimaryExpression_CasesAssignment_14_1_3(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new PrimaryExpression_INDENTTerminalRuleCall_14_1_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+// IdRef
+protected class PrimaryExpression_IdRefParserRuleCall_15 extends RuleCallToken {
+
+ public PrimaryExpression_IdRefParserRuleCall_15(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IdRef_ValAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(IdRef_ValAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule PrimaryExpression ****************/
+
+
+/************ begin Rule Block ****************
+ *
+ * Block:
+ * {Block} INDENT Body? OUTDENT;
+ *
+ **/
+
+// {Block} INDENT Body? OUTDENT
+protected class Block_Group extends GroupToken {
+
+ public Block_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getBlockAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_OUTDENTTerminalRuleCall_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBlockAccess().getBlockAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getBodyRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {Block}
+protected class Block_BlockAction_0 extends ActionToken {
+
+ public Block_BlockAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getBlockAccess().getBlockAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// INDENT
+protected class Block_INDENTTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public Block_INDENTTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_BlockAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// Body?
+protected class Block_BodyParserRuleCall_2 extends RuleCallToken {
+
+ public Block_BodyParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBlockAccess().getBodyParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Body_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_INDENTTerminalRuleCall_1(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class Block_OUTDENTTerminalRuleCall_3 extends UnassignedTextToken {
+
+ public Block_OUTDENTTerminalRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_BodyParserRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Block_INDENTTerminalRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule Block ****************/
+
+
+/************ begin Rule Case ****************
+ *
+ * // a switch case (called When in coffeescript)
+ * Case:
+ * LEADING_WHEN whens+=Expression (COMMA whens+=Expression)* then=Block TERMINATOR?;
+ *
+ **/
+
+// LEADING_WHEN whens+=Expression (COMMA whens+=Expression)* then=Block TERMINATOR?
+protected class Case_Group extends GroupToken {
+
+ public Case_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCaseAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Case_ThenAssignment_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCaseRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// LEADING_WHEN
+protected class Case_LEADING_WHENTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public Case_LEADING_WHENTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// whens+=Expression
+protected class Case_WhensAssignment_1 extends AssignmentToken {
+
+ public Case_WhensAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCaseAccess().getWhensAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("whens",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("whens");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Case_LEADING_WHENTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (COMMA whens+=Expression)*
+protected class Case_Group_2 extends GroupToken {
+
+ public Case_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCaseAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Case_WhensAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class Case_COMMATerminalRuleCall_2_0 extends UnassignedTextToken {
+
+ public Case_COMMATerminalRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Case_Group_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Case_WhensAssignment_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// whens+=Expression
+protected class Case_WhensAssignment_2_1 extends AssignmentToken {
+
+ public Case_WhensAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCaseAccess().getWhensAssignment_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("whens",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("whens");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Case_COMMATerminalRuleCall_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// then=Block
+protected class Case_ThenAssignment_3 extends AssignmentToken {
+
+ public Case_ThenAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCaseAccess().getThenAssignment_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("then",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("then");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Case_Group_2(lastRuleCallOrigin, next, actIndex, consumed);
+ case 1: return new Case_WhensAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule Case ****************/
+
+
+/************ begin Rule IfExp ****************
+ *
+ * IfExp:
+ * blocks+=CondBlock (ELSE blocks+=CondBlock)* (ELSE defaultBlock=Block)?;
+ *
+ **/
+
+// blocks+=CondBlock (ELSE blocks+=CondBlock)* (ELSE defaultBlock=Block)?
+protected class IfExp_Group extends GroupToken {
+
+ public IfExp_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_Group_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new IfExp_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new IfExp_BlocksAssignment_0(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIfExpRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// blocks+=CondBlock
+protected class IfExp_BlocksAssignment_0 extends AssignmentToken {
+
+ public IfExp_BlocksAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getBlocksAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CondBlock_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("blocks",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("blocks");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getCondBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (ELSE blocks+=CondBlock)*
+protected class IfExp_Group_1 extends GroupToken {
+
+ public IfExp_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_BlocksAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// ELSE
+protected class IfExp_ELSETerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public IfExp_ELSETerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new IfExp_BlocksAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// blocks+=CondBlock
+protected class IfExp_BlocksAssignment_1_1 extends AssignmentToken {
+
+ public IfExp_BlocksAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getBlocksAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CondBlock_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("blocks",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("blocks");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getCondBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new IfExp_ELSETerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// (ELSE defaultBlock=Block)?
+protected class IfExp_Group_2 extends GroupToken {
+
+ public IfExp_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_DefaultBlockAssignment_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// ELSE
+protected class IfExp_ELSETerminalRuleCall_2_0 extends UnassignedTextToken {
+
+ public IfExp_ELSETerminalRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IfExp_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new IfExp_BlocksAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// defaultBlock=Block
+protected class IfExp_DefaultBlockAssignment_2_1 extends AssignmentToken {
+
+ public IfExp_DefaultBlockAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIfExpAccess().getDefaultBlockAssignment_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("defaultBlock",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("defaultBlock");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new IfExp_ELSETerminalRuleCall_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule IfExp ****************/
+
+
+/************ begin Rule CondBlock ****************
+ *
+ * // IF can be 'if' or 'unless'
+ * CondBlock:
+ * operator=IF condition=Expression action=Block;
+ *
+ **/
+
+// operator=IF condition=Expression action=Block
+protected class CondBlock_Group extends GroupToken {
+
+ public CondBlock_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getCondBlockAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new CondBlock_ActionAssignment_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getCondBlockRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// operator=IF
+protected class CondBlock_OperatorAssignment_0 extends AssignmentToken {
+
+ public CondBlock_OperatorAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCondBlockAccess().getOperatorAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("operator",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("operator");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// condition=Expression
+protected class CondBlock_ConditionAssignment_1 extends AssignmentToken {
+
+ public CondBlock_ConditionAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCondBlockAccess().getConditionAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("condition",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("condition");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new CondBlock_OperatorAssignment_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// action=Block
+protected class CondBlock_ActionAssignment_2 extends AssignmentToken {
+
+ public CondBlock_ActionAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getCondBlockAccess().getActionAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("action",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("action");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new CondBlock_ConditionAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule CondBlock ****************/
+
+
+/************ begin Rule IdRef ****************
+ *
+ * IdRef:
+ * val=[Id|IDENTIFIER];
+ *
+ **/
+
+// val=[Id|IDENTIFIER]
+protected class IdRef_ValAssignment extends AssignmentToken {
+
+ public IdRef_ValAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIdRefAccess().getValAssignment();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ if((value = eObjectConsumer.getConsumable("val",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("val");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRefAccess().getValIdCrossReference_0().getType().getClassifier())) {
+ type = AssignmentType.CROSS_REFERENCE;
+ element = grammarAccess.getIdRefAccess().getValIdCrossReference_0();
+ return obj;
+ }
+ }
+ return null;
+ }
+
+}
+
+/************ end Rule IdRef ****************/
+
+
+/************ begin Rule Id ****************
+ *
+ * Id:
+ * name=IDENTIFIER;
+ *
+ **/
+
+// name=IDENTIFIER
+protected class Id_NameAssignment extends AssignmentToken {
+
+ public Id_NameAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getIdAccess().getNameAssignment();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+/************ end Rule Id ****************/
+
+
+/************ begin Rule Property ****************
+ *
+ * Property:
+ * => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id // FIXME: property is actually "Expression Accessor"
+ * | => (IdRef INDEX_START) index=Index INDEX_END;
+ *
+ **/
+
+// => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id // FIXME: property is actually "Expression Accessor"
+// | => (IdRef INDEX_START) index=Index INDEX_END
+protected class Property_Alternatives extends AlternativesToken {
+
+ public Property_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Property_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id
+protected class Property_Group_0 extends GroupToken {
+
+ public Property_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_PropAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT))
+protected class Property_Group_0_0 extends GroupToken {
+
+ public Property_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Group_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)
+protected class Property_Group_0_0_0 extends GroupToken {
+
+ public Property_Group_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_AccessorAssignment_0_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// IdRef
+protected class Property_IdRefParserRuleCall_0_0_0_0 extends RuleCallToken {
+
+ public Property_IdRefParserRuleCall_0_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IdRef_ValAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(IdRef_ValAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)
+protected class Property_AccessorAssignment_0_0_0_1 extends AssignmentToken {
+
+ public Property_AccessorAssignment_0_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getAccessorAssignment_0_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_IdRefParserRuleCall_0_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("accessor",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("accessor");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1();
+ return obj;
+ }
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+
+// prop=Id
+protected class Property_PropAssignment_0_1 extends AssignmentToken {
+
+ public Property_PropAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getPropAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("prop",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("prop");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Property_Group_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// => (IdRef INDEX_START) index=Index INDEX_END
+protected class Property_Group_1 extends GroupToken {
+
+ public Property_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_INDEX_ENDTerminalRuleCall_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => (IdRef INDEX_START)
+protected class Property_Group_1_0 extends GroupToken {
+
+ public Property_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// IdRef INDEX_START
+protected class Property_Group_1_0_0 extends GroupToken {
+
+ public Property_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getGroup_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_INDEX_STARTTerminalRuleCall_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// IdRef
+protected class Property_IdRefParserRuleCall_1_0_0_0 extends RuleCallToken {
+
+ public Property_IdRefParserRuleCall_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new IdRef_ValAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(IdRef_ValAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// INDEX_START
+protected class Property_INDEX_STARTTerminalRuleCall_1_0_0_1 extends UnassignedTextToken {
+
+ public Property_INDEX_STARTTerminalRuleCall_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_IdRefParserRuleCall_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+// index=Index
+protected class Property_IndexAssignment_1_1 extends AssignmentToken {
+
+ public Property_IndexAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getIndexAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Index_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("index",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("index");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIndexRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Property_Group_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDEX_END
+protected class Property_INDEX_ENDTerminalRuleCall_1_2 extends UnassignedTextToken {
+
+ public Property_INDEX_ENDTerminalRuleCall_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_IndexAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+/************ end Rule Property ****************/
+
+
+/************ begin Rule Variable ****************
+ *
+ * Variable:
+ * Id | (AT_SIGIL | THIS DOT) Id (DOT props+=Id)* | Property;
+ *
+ **/
+
+// Id | (AT_SIGIL | THIS DOT) Id (DOT props+=Id)* | Property
+protected class Variable_Alternatives extends AlternativesToken {
+
+ public Variable_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getVariableAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_IdParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Variable_Group_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Variable_PropertyParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Id
+protected class Variable_IdParserRuleCall_0 extends RuleCallToken {
+
+ public Variable_IdParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getIdParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// (AT_SIGIL | THIS DOT) Id (DOT props+=Id)*
+protected class Variable_Group_1 extends GroupToken {
+
+ public Variable_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getVariableAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Group_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Variable_IdParserRuleCall_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// AT_SIGIL | THIS DOT
+protected class Variable_Alternatives_1_0 extends AlternativesToken {
+
+ public Variable_Alternatives_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getVariableAccess().getAlternatives_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_AT_SIGILTerminalRuleCall_1_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// AT_SIGIL
+protected class Variable_AT_SIGILTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public Variable_AT_SIGILTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+
+// Id
+protected class Variable_IdParserRuleCall_1_1 extends RuleCallToken {
+
+ public Variable_IdParserRuleCall_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getIdParserRuleCall_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Alternatives_1_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// (DOT props+=Id)*
+protected class Variable_Group_1_2 extends GroupToken {
+
+ public Variable_Group_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getVariableAccess().getGroup_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_PropsAssignment_1_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// DOT
+protected class Variable_DOTTerminalRuleCall_1_2_0 extends UnassignedTextToken {
+
+ public Variable_DOTTerminalRuleCall_1_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Group_1_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Variable_IdParserRuleCall_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// props+=Id
+protected class Variable_PropsAssignment_1_2_1 extends AssignmentToken {
+
+ public Variable_PropsAssignment_1_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getVariableAccess().getPropsAssignment_1_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("props",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("props");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getIdRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Variable_DOTTerminalRuleCall_1_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// Property
+protected class Variable_PropertyParserRuleCall_2 extends RuleCallToken {
+
+ public Variable_PropertyParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getVariableAccess().getPropertyParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Property_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Property_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Variable ****************/
+
+
+/************ begin Rule AssignableArray ****************
+ *
+ * / ** An array that can be on the left-hand side of an assignment * / AssignableArray:
+ * LBRACKET AssignableArgList RBRACKET;
+ *
+ **/
+
+// => LBRACKET AssignableArgList RBRACKET
+protected class AssignableArray_Group extends GroupToken {
+
+ public AssignableArray_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignableArrayAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArray_RBRACKETTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgListRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => LBRACKET
+protected class AssignableArray_LBRACKETTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public AssignableArray_LBRACKETTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// AssignableArgList
+protected class AssignableArray_AssignableArgListParserRuleCall_1 extends RuleCallToken {
+
+ public AssignableArray_AssignableArgListParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(AssignableArgList_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArray_LBRACKETTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// RBRACKET
+protected class AssignableArray_RBRACKETTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public AssignableArray_RBRACKETTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArray_AssignableArgListParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule AssignableArray ****************/
+
+
+/************ begin Rule AssignableArgList ****************
+ *
+ * AssignableArgList:
+ * args+=AssignableArg (COMMA args+=AssignableArg)*;
+ *
+ **/
+
+// args+=AssignableArg (COMMA args+=AssignableArg)*
+protected class AssignableArgList_Group extends GroupToken {
+
+ public AssignableArgList_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArgList_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignableArgList_ArgsAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgListRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// args+=AssignableArg
+protected class AssignableArgList_ArgsAssignment_0 extends AssignmentToken {
+
+ public AssignableArgList_ArgsAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getArgsAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArg_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("args",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("args");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignableArgRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (COMMA args+=AssignableArg)*
+protected class AssignableArgList_Group_1 extends GroupToken {
+
+ public AssignableArgList_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArgList_ArgsAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class AssignableArgList_COMMATerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public AssignableArgList_COMMATerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArgList_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignableArgList_ArgsAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// args+=AssignableArg
+protected class AssignableArgList_ArgsAssignment_1_1 extends AssignmentToken {
+
+ public AssignableArgList_ArgsAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignableArgListAccess().getArgsAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArg_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("args",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("args");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignableArgRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new AssignableArgList_COMMATerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule AssignableArgList ****************/
+
+
+/************ begin Rule AssignableArg ****************
+ *
+ * AssignableArg:
+ * arg=Assignable splat?=ELLIPSIS?;
+ *
+ **/
+
+// arg=Assignable splat?=ELLIPSIS?
+protected class AssignableArg_Group extends GroupToken {
+
+ public AssignableArg_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getAssignableArgAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArg_SplatAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new AssignableArg_ArgAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// arg=Assignable
+protected class AssignableArg_ArgAssignment_0 extends AssignmentToken {
+
+ public AssignableArg_ArgAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignableArgAccess().getArgAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignable_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("arg",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("arg");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getAssignableRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// splat?=ELLIPSIS?
+protected class AssignableArg_SplatAssignment_1 extends AssignmentToken {
+
+ public AssignableArg_SplatAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getAssignableArgAccess().getSplatAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArg_ArgAssignment_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("splat",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("splat");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+/************ end Rule AssignableArg ****************/
+
+
+/************ begin Rule Assignable ****************
+ *
+ * Assignable:
+ * Variable | Dictionary | AssignableArray;
+ *
+ **/
+
+// Variable | Dictionary | AssignableArray
+protected class Assignable_Alternatives extends AlternativesToken {
+
+ public Assignable_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getAssignableAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Assignable_VariableParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Assignable_DictionaryParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Assignable_AssignableArrayParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgListRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Variable
+protected class Assignable_VariableParserRuleCall_0 extends RuleCallToken {
+
+ public Assignable_VariableParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableAccess().getVariableParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Variable_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRefRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Variable_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Dictionary
+protected class Assignable_DictionaryParserRuleCall_1 extends RuleCallToken {
+
+ public Assignable_DictionaryParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Dictionary_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// AssignableArray
+protected class Assignable_AssignableArrayParserRuleCall_2 extends RuleCallToken {
+
+ public Assignable_AssignableArrayParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new AssignableArray_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getAssignableArgListRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(AssignableArray_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Assignable ****************/
+
+
+/************ begin Rule Arg ****************
+ *
+ * / *
+ * * FIXME: handle more complex assignables
+ * * / Arg:
+ * exp=Expression splat?=ELLIPSIS?;
+ *
+ **/
+
+// exp=Expression splat?=ELLIPSIS?
+protected class Arg_Group extends GroupToken {
+
+ public Arg_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Arg_SplatAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Arg_ExpAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// exp=Expression
+protected class Arg_ExpAssignment_0 extends AssignmentToken {
+
+ public Arg_ExpAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgAccess().getExpAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("exp",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("exp");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// splat?=ELLIPSIS?
+protected class Arg_SplatAssignment_1 extends AssignmentToken {
+
+ public Arg_SplatAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgAccess().getSplatAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Arg_ExpAssignment_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("splat",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("splat");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+
+/************ end Rule Arg ****************/
+
+
+/************ begin Rule ArgLine ****************
+ *
+ * ArgLine:
+ * head=Arg (COMMA tail+=Arg)* COMMA?;
+ *
+ **/
+
+// head=Arg (COMMA tail+=Arg)* COMMA?
+protected class ArgLine_Group extends GroupToken {
+
+ public ArgLine_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ArgLine_HeadAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgLineRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// head=Arg
+protected class ArgLine_HeadAssignment_0 extends AssignmentToken {
+
+ public ArgLine_HeadAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getHeadAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Arg_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("head",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("head");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (COMMA tail+=Arg)*
+protected class ArgLine_Group_1 extends GroupToken {
+
+ public ArgLine_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_TailAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class ArgLine_COMMATerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public ArgLine_COMMATerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ArgLine_HeadAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// tail+=Arg
+protected class ArgLine_TailAssignment_1_1 extends AssignmentToken {
+
+ public ArgLine_TailAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgLineAccess().getTailAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Arg_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("tail",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("tail");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ArgLine_COMMATerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule ArgLine ****************/
+
+
+/************ begin Rule ExplicitArgList ****************
+ *
+ * ExplicitArgList:
+ * lines+=ArgLine (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*;
+ *
+ **/
+
+// lines+=ArgLine (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*
+protected class ExplicitArgList_Group extends GroupToken {
+
+ public ExplicitArgList_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitArgList_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getExplicitArgListRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// lines+=ArgLine
+protected class ExplicitArgList_LinesAssignment_0 extends AssignmentToken {
+
+ public ExplicitArgList_LinesAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getLinesAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*
+protected class ExplicitArgList_Alternatives_1 extends AlternativesToken {
+
+ public ExplicitArgList_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Group_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitArgList_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR lines+=ArgLine
+protected class ExplicitArgList_Group_1_0 extends GroupToken {
+
+ public ExplicitArgList_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_LinesAssignment_1_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR
+protected class ExplicitArgList_TERMINATORTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public ExplicitArgList_TERMINATORTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitArgList_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=ArgLine
+protected class ExplicitArgList_LinesAssignment_1_0_1 extends AssignmentToken {
+
+ public ExplicitArgList_LinesAssignment_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ExplicitArgList_TERMINATORTerminalRuleCall_1_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// INDENT lines+=ArgLine OUTDENT
+protected class ExplicitArgList_Group_1_1 extends GroupToken {
+
+ public ExplicitArgList_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_OUTDENTTerminalRuleCall_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class ExplicitArgList_INDENTTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public ExplicitArgList_INDENTTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitArgList_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=ArgLine
+protected class ExplicitArgList_LinesAssignment_1_1_1 extends AssignmentToken {
+
+ public ExplicitArgList_LinesAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getLinesAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getArgLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ExplicitArgList_INDENTTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class ExplicitArgList_OUTDENTTerminalRuleCall_1_1_2 extends UnassignedTextToken {
+
+ public ExplicitArgList_OUTDENTTerminalRuleCall_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_LinesAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+/************ end Rule ExplicitArgList ****************/
+
+
+/************ begin Rule ArgList ****************
+ *
+ * ArgList:
+ * {ArgList} (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?;
+ *
+ **/
+
+// {ArgList} (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?
+protected class ArgList_Group extends GroupToken {
+
+ public ArgList_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgListAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ArgList_ArgListAction_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {ArgList}
+protected class ArgList_ArgListAction_0 extends ActionToken {
+
+ public ArgList_ArgListAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getArgListAccess().getArgListAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?
+protected class ArgList_Alternatives_1 extends AlternativesToken {
+
+ public ArgList_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getArgListAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_DummyAssignment_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ArgList_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// dummy=ExplicitArgList
+protected class ArgList_DummyAssignment_1_0 extends AssignmentToken {
+
+ public ArgList_DummyAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgListAccess().getDummyAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dummy",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dummy");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExplicitArgListRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ArgList_ArgListAction_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDENT dummy=ExplicitArgList OUTDENT
+protected class ArgList_Group_1_1 extends GroupToken {
+
+ public ArgList_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArgListAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_OUTDENTTerminalRuleCall_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class ArgList_INDENTTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public ArgList_INDENTTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_ArgListAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// dummy=ExplicitArgList
+protected class ArgList_DummyAssignment_1_1_1 extends AssignmentToken {
+
+ public ArgList_DummyAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getArgListAccess().getDummyAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dummy",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dummy");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExplicitArgListRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ArgList_INDENTTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class ArgList_OUTDENTTerminalRuleCall_1_1_2 extends UnassignedTextToken {
+
+ public ArgList_OUTDENTTerminalRuleCall_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_DummyAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+/************ end Rule ArgList ****************/
+
+
+/************ begin Rule Array ****************
+ *
+ * Array:
+ * LBRACKET ArgList RBRACKET;
+ *
+ **/
+
+// => LBRACKET ArgList RBRACKET
+protected class Array_Group extends GroupToken {
+
+ public Array_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getArrayAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_RBRACKETTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => LBRACKET
+protected class Array_LBRACKETTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public Array_LBRACKETTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// ArgList
+protected class Array_ArgListParserRuleCall_1 extends RuleCallToken {
+
+ public Array_ArgListParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArrayAccess().getArgListParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ArgList_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(ArgList_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_LBRACKETTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// RBRACKET
+protected class Array_RBRACKETTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public Array_RBRACKETTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_ArgListParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule Array ****************/
+
+
+/************ begin Rule Dictionary ****************
+ *
+ * // Object in coffeescript
+ * Dictionary:
+ * LCURLY DictItems RCURLY;
+ *
+ **/
+
+// => LCURLY DictItems RCURLY
+protected class Dictionary_Group extends GroupToken {
+
+ public Dictionary_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictionaryAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_RCURLYTerminalRuleCall_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => LCURLY
+protected class Dictionary_LCURLYTerminalRuleCall_0 extends UnassignedTextToken {
+
+ public Dictionary_LCURLYTerminalRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// DictItems
+protected class Dictionary_DictItemsParserRuleCall_1 extends RuleCallToken {
+
+ public Dictionary_DictItemsParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(checkForRecursion(DictItems_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_LCURLYTerminalRuleCall_0(lastRuleCallOrigin, next, actIndex, inst);
+ default: return null;
+ }
+ }
+}
+
+// RCURLY
+protected class Dictionary_RCURLYTerminalRuleCall_2 extends UnassignedTextToken {
+
+ public Dictionary_RCURLYTerminalRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_DictItemsParserRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule Dictionary ****************/
+
+
+/************ begin Rule DictItems ****************
+ *
+ * DictItems:
+ * {DictItems} (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?;
+ *
+ **/
+
+// {DictItems} (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?
+protected class DictItems_Group extends GroupToken {
+
+ public DictItems_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictItems_DictItemsAction_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {DictItems}
+protected class DictItems_DictItemsAction_0 extends ActionToken {
+
+ public DictItems_DictItemsAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getDictItemsAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?
+protected class DictItems_Alternatives_1 extends AlternativesToken {
+
+ public DictItems_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_DummyAssignment_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictItems_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// dummy=ExplicitDictItems
+protected class DictItems_DummyAssignment_1_0 extends AssignmentToken {
+
+ public DictItems_DummyAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getDummyAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dummy",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dummy");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExplicitDictItemsRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItems_DictItemsAction_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDENT dummy=ExplicitDictItems OUTDENT
+protected class DictItems_Group_1_1 extends GroupToken {
+
+ public DictItems_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_OUTDENTTerminalRuleCall_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class DictItems_INDENTTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public DictItems_INDENTTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_DictItemsAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// dummy=ExplicitDictItems
+protected class DictItems_DummyAssignment_1_1_1 extends AssignmentToken {
+
+ public DictItems_DummyAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getDummyAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("dummy",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dummy");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExplicitDictItemsRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItems_INDENTTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class DictItems_OUTDENTTerminalRuleCall_1_1_2 extends UnassignedTextToken {
+
+ public DictItems_OUTDENTTerminalRuleCall_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItems_DummyAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+/************ end Rule DictItems ****************/
+
+
+/************ begin Rule ExplicitDictItems ****************
+ *
+ * ExplicitDictItems:
+ * lines+=DictLine (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*;
+ *
+ **/
+
+// lines+=DictLine (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*
+protected class ExplicitDictItems_Group extends GroupToken {
+
+ public ExplicitDictItems_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitDictItems_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getExplicitDictItemsRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// lines+=DictLine
+protected class ExplicitDictItems_LinesAssignment_0 extends AssignmentToken {
+
+ public ExplicitDictItems_LinesAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*
+protected class ExplicitDictItems_Alternatives_1 extends AlternativesToken {
+
+ public ExplicitDictItems_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Group_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitDictItems_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR lines+=DictLine
+protected class ExplicitDictItems_Group_1_0 extends GroupToken {
+
+ public ExplicitDictItems_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getGroup_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_LinesAssignment_1_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// TERMINATOR
+protected class ExplicitDictItems_TERMINATORTerminalRuleCall_1_0_0 extends UnassignedTextToken {
+
+ public ExplicitDictItems_TERMINATORTerminalRuleCall_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitDictItems_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=DictLine
+protected class ExplicitDictItems_LinesAssignment_1_0_1 extends AssignmentToken {
+
+ public ExplicitDictItems_LinesAssignment_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ExplicitDictItems_TERMINATORTerminalRuleCall_1_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+// INDENT lines+=DictLine OUTDENT
+protected class ExplicitDictItems_Group_1_1 extends GroupToken {
+
+ public ExplicitDictItems_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_OUTDENTTerminalRuleCall_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class ExplicitDictItems_INDENTTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public ExplicitDictItems_INDENTTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new ExplicitDictItems_LinesAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// lines+=DictLine
+protected class ExplicitDictItems_LinesAssignment_1_1_1 extends AssignmentToken {
+
+ public ExplicitDictItems_LinesAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getLinesAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("lines",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lines");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictLineRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new ExplicitDictItems_INDENTTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class ExplicitDictItems_OUTDENTTerminalRuleCall_1_1_2 extends UnassignedTextToken {
+
+ public ExplicitDictItems_OUTDENTTerminalRuleCall_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ExplicitDictItems_LinesAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+/************ end Rule ExplicitDictItems ****************/
+
+
+/************ begin Rule DictLine ****************
+ *
+ * DictLine:
+ * head=DictItem (COMMA tail+=DictItem)* COMMA?;
+ *
+ **/
+
+// head=DictItem (COMMA tail+=DictItem)* COMMA?
+protected class DictLine_Group extends GroupToken {
+
+ public DictLine_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictLine_HeadAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictLineRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// head=DictItem
+protected class DictLine_HeadAssignment_0 extends AssignmentToken {
+
+ public DictLine_HeadAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getHeadAssignment_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("head",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("head");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictItemRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
+ }
+ }
+}
+
+// (COMMA tail+=DictItem)*
+protected class DictLine_Group_1 extends GroupToken {
+
+ public DictLine_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_TailAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class DictLine_COMMATerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public DictLine_COMMATerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictLine_Group_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictLine_HeadAssignment_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// tail+=DictItem
+protected class DictLine_TailAssignment_1_1 extends AssignmentToken {
+
+ public DictLine_TailAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictLineAccess().getTailAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("tail",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("tail");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictItemRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictLine_COMMATerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+/************ end Rule DictLine ****************/
+
+
+/************ begin Rule DictItem ****************
+ *
+ * DictItem:
+ * {DictItem} key=DictKey (COLON (value=Expression | INDENT value=Expression OUTDENT))?;
+ *
+ **/
+
+// {DictItem} key=DictKey (COLON (value=Expression | INDENT value=Expression OUTDENT))?
+protected class DictItem_Group extends GroupToken {
+
+ public DictItem_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_Group_2(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictItem_KeyAssignment_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemAccess().getDictItemAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {DictItem}
+protected class DictItem_DictItemAction_0 extends ActionToken {
+
+ public DictItem_DictItemAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getDictItemAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// key=DictKey
+protected class DictItem_KeyAssignment_1 extends AssignmentToken {
+
+ public DictItem_KeyAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getKeyAssignment_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictKey_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("key",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("key");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getDictKeyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItem_DictItemAction_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (COLON (value=Expression | INDENT value=Expression OUTDENT))?
+protected class DictItem_Group_2 extends GroupToken {
+
+ public DictItem_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getGroup_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_Alternatives_2_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COLON
+protected class DictItem_COLONTerminalRuleCall_2_0 extends UnassignedTextToken {
+
+ public DictItem_COLONTerminalRuleCall_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_KeyAssignment_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// value=Expression | INDENT value=Expression OUTDENT
+protected class DictItem_Alternatives_2_1 extends AlternativesToken {
+
+ public DictItem_Alternatives_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getAlternatives_2_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_ValueAssignment_2_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictItem_Group_2_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// value=Expression
+protected class DictItem_ValueAssignment_2_1_0 extends AssignmentToken {
+
+ public DictItem_ValueAssignment_2_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getValueAssignment_2_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("value",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("value");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItem_COLONTerminalRuleCall_2_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// INDENT value=Expression OUTDENT
+protected class DictItem_Group_2_1_1 extends GroupToken {
+
+ public DictItem_Group_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getGroup_2_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_OUTDENTTerminalRuleCall_2_1_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// INDENT
+protected class DictItem_INDENTTerminalRuleCall_2_1_1_0 extends UnassignedTextToken {
+
+ public DictItem_INDENTTerminalRuleCall_2_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_COLONTerminalRuleCall_2_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// value=Expression
+protected class DictItem_ValueAssignment_2_1_1_1 extends AssignmentToken {
+
+ public DictItem_ValueAssignment_2_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getValueAssignment_2_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("value",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("value");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new DictItem_INDENTTerminalRuleCall_2_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class DictItem_OUTDENTTerminalRuleCall_2_1_1_2 extends UnassignedTextToken {
+
+ public DictItem_OUTDENTTerminalRuleCall_2_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictItem_ValueAssignment_2_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+
+
+/************ end Rule DictItem ****************/
+
+
+/************ begin Rule DictKey ****************
+ *
+ * DictKey:
+ * Literal | Id;
+ *
+ **/
+
+// Literal | Id
+protected class DictKey_Alternatives extends AlternativesToken {
+
+ public DictKey_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getDictKeyAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new DictKey_LiteralParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new DictKey_IdParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Literal
+protected class DictKey_LiteralParserRuleCall_0 extends RuleCallToken {
+
+ public DictKey_LiteralParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Literal_Alternatives(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Literal_Alternatives.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Id
+protected class DictKey_IdParserRuleCall_1 extends RuleCallToken {
+
+ public DictKey_IdParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getDictKeyAccess().getIdParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule DictKey ****************/
+
+
+/************ begin Rule Lambda ****************
+ *
+ * // Code in coffeescript
+ * Lambda:
+ * (PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)? (FUNC_ARROW | BOUND_FUNC_ARROW) body=Block;
+ *
+ **/
+
+// (PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)? (FUNC_ARROW | BOUND_FUNC_ARROW) body=Block
+protected class Lambda_Group extends GroupToken {
+
+ public Lambda_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_BodyAssignment_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getLambdaRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// (PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)?
+protected class Lambda_Group_0 extends GroupToken {
+
+ public Lambda_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_PARAM_ENDTerminalRuleCall_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// PARAM_START
+protected class Lambda_PARAM_STARTTerminalRuleCall_0_0 extends UnassignedTextToken {
+
+ public Lambda_PARAM_STARTTerminalRuleCall_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// (params+=Param (COMMA params+=Param)*)?
+protected class Lambda_Group_0_1 extends GroupToken {
+
+ public Lambda_Group_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getGroup_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group_0_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Lambda_ParamsAssignment_0_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// params+=Param
+protected class Lambda_ParamsAssignment_0_1_0 extends AssignmentToken {
+
+ public Lambda_ParamsAssignment_0_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getParamsAssignment_0_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("params",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("params");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getParamRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Lambda_PARAM_STARTTerminalRuleCall_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// (COMMA params+=Param)*
+protected class Lambda_Group_0_1_1 extends GroupToken {
+
+ public Lambda_Group_0_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getGroup_0_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_ParamsAssignment_0_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// COMMA
+protected class Lambda_COMMATerminalRuleCall_0_1_1_0 extends UnassignedTextToken {
+
+ public Lambda_COMMATerminalRuleCall_0_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group_0_1_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Lambda_ParamsAssignment_0_1_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// params+=Param
+protected class Lambda_ParamsAssignment_0_1_1_1 extends AssignmentToken {
+
+ public Lambda_ParamsAssignment_0_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getParamsAssignment_0_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("params",false)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("params");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getParamRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Lambda_COMMATerminalRuleCall_0_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+// PARAM_END
+protected class Lambda_PARAM_ENDTerminalRuleCall_0_2 extends UnassignedTextToken {
+
+ public Lambda_PARAM_ENDTerminalRuleCall_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group_0_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Lambda_PARAM_STARTTerminalRuleCall_0_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+// FUNC_ARROW | BOUND_FUNC_ARROW
+protected class Lambda_Alternatives_1 extends AlternativesToken {
+
+ public Lambda_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_FUNC_ARROWTerminalRuleCall_1_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// FUNC_ARROW
+protected class Lambda_FUNC_ARROWTerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public Lambda_FUNC_ARROWTerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Lambda_Group_0(lastRuleCallOrigin, this, 0, inst);
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index - 1, inst);
+ }
+ }
+
+}
+
+
+// body=Block
+protected class Lambda_BodyAssignment_2 extends AssignmentToken {
+
+ public Lambda_BodyAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getLambdaAccess().getBodyAssignment_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Block_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("body",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("body");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBlockRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Lambda_Alternatives_1(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+/************ end Rule Lambda ****************/
+
+
+/************ begin Rule Param ****************
+ *
+ * Param:
+ * (Id | Array | Dictionary | ThisProperty) (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?;
+ *
+ **/
+
+// (Id | Array | Dictionary | ThisProperty) (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?
+protected class Param_Group extends GroupToken {
+
+ public Param_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParamAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Param_Alternatives_0(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// Id | Array | Dictionary | ThisProperty
+protected class Param_Alternatives_0 extends AlternativesToken {
+
+ public Param_Alternatives_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getParamAccess().getAlternatives_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_IdParserRuleCall_0_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Param_ArrayParserRuleCall_0_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Param_DictionaryParserRuleCall_0_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new Param_ThisPropertyParserRuleCall_0_3(lastRuleCallOrigin, this, 3, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// Id
+protected class Param_IdParserRuleCall_0_0 extends RuleCallToken {
+
+ public Param_IdParserRuleCall_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getIdParserRuleCall_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Id_NameAssignment(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Id_NameAssignment.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Array
+protected class Param_ArrayParserRuleCall_0_1 extends RuleCallToken {
+
+ public Param_ArrayParserRuleCall_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getArrayParserRuleCall_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Array_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getArgListAccess().getArgListAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Array_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// Dictionary
+protected class Param_DictionaryParserRuleCall_0_2 extends RuleCallToken {
+
+ public Param_DictionaryParserRuleCall_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Dictionary_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getDictItemsAccess().getDictItemsAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(Dictionary_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// ThisProperty
+protected class Param_ThisPropertyParserRuleCall_0_3 extends RuleCallToken {
+
+ public Param_ThisPropertyParserRuleCall_0_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new ThisProperty_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getIdRule().getType().getClassifier())
+ return null;
+ if(checkForRecursion(ThisProperty_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+// (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?
+protected class Param_Alternatives_1 extends AlternativesToken {
+
+ public Param_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getParamAccess().getAlternatives_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_SplatAssignment_1_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Param_Group_1_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// splat?=ELLIPSIS
+protected class Param_SplatAssignment_1_0 extends AssignmentToken {
+
+ public Param_SplatAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getParamAccess().getSplatAssignment_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Alternatives_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("splat",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("splat");
+ if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0(), value, null)) {
+ type = AssignmentType.TERMINAL_RULE_CALL;
+ element = grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0();
+ return obj;
+ }
+ return null;
+ }
+
+}
+
+// EQUAL defaultValue=Expression
+protected class Param_Group_1_1 extends GroupToken {
+
+ public Param_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParamAccess().getGroup_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_DefaultValueAssignment_1_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// EQUAL
+protected class Param_EQUALTerminalRuleCall_1_1_0 extends UnassignedTextToken {
+
+ public Param_EQUALTerminalRuleCall_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Param_Alternatives_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// defaultValue=Expression
+protected class Param_DefaultValueAssignment_1_1_1 extends AssignmentToken {
+
+ public Param_DefaultValueAssignment_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getParamAccess().getDefaultValueAssignment_1_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Expression_PostfixParserRuleCall(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("defaultValue",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("defaultValue");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Param_EQUALTerminalRuleCall_1_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+
+
+
+/************ end Rule Param ****************/
+
+
+/************ begin Rule NumberLiteral ****************
+ *
+ * NumberLiteral:
+ * {NumberLiteral} NUMBER;
+ *
+ **/
+
+// {NumberLiteral} NUMBER
+protected class NumberLiteral_Group extends GroupToken {
+
+ public NumberLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getNumberLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NumberLiteral_NUMBERTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {NumberLiteral}
+protected class NumberLiteral_NumberLiteralAction_0 extends ActionToken {
+
+ public NumberLiteral_NumberLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// NUMBER
+protected class NumberLiteral_NUMBERTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public NumberLiteral_NUMBERTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NumberLiteral_NumberLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule NumberLiteral ****************/
+
+
+/************ begin Rule StringLiteral ****************
+ *
+ * StringLiteral:
+ * {StringLiteral} STRING;
+ *
+ **/
+
+// {StringLiteral} STRING
+protected class StringLiteral_Group extends GroupToken {
+
+ public StringLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getStringLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new StringLiteral_STRINGTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {StringLiteral}
+protected class StringLiteral_StringLiteralAction_0 extends ActionToken {
+
+ public StringLiteral_StringLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getStringLiteralAccess().getStringLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// STRING
+protected class StringLiteral_STRINGTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public StringLiteral_STRINGTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new StringLiteral_StringLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule StringLiteral ****************/
+
+
+/************ begin Rule BoolLiteral ****************
+ *
+ * BoolLiteral:
+ * {BoolLiteral} BOOL;
+ *
+ **/
+
+// {BoolLiteral} BOOL
+protected class BoolLiteral_Group extends GroupToken {
+
+ public BoolLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getBoolLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new BoolLiteral_BOOLTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {BoolLiteral}
+protected class BoolLiteral_BoolLiteralAction_0 extends ActionToken {
+
+ public BoolLiteral_BoolLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// BOOL
+protected class BoolLiteral_BOOLTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public BoolLiteral_BOOLTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new BoolLiteral_BoolLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule BoolLiteral ****************/
+
+
+/************ begin Rule JSLiteral ****************
+ *
+ * JSLiteral:
+ * {JSLiteral} JS;
+ *
+ **/
+
+// {JSLiteral} JS
+protected class JSLiteral_Group extends GroupToken {
+
+ public JSLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getJSLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new JSLiteral_JSTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {JSLiteral}
+protected class JSLiteral_JSLiteralAction_0 extends ActionToken {
+
+ public JSLiteral_JSLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getJSLiteralAccess().getJSLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// JS
+protected class JSLiteral_JSTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public JSLiteral_JSTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new JSLiteral_JSLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule JSLiteral ****************/
+
+
+/************ begin Rule RegexLiteral ****************
+ *
+ * RegexLiteral:
+ * {RegexLiteral} REGEX;
+ *
+ **/
+
+// {RegexLiteral} REGEX
+protected class RegexLiteral_Group extends GroupToken {
+
+ public RegexLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getRegexLiteralAccess().getGroup();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RegexLiteral_REGEXTerminalRuleCall_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// {RegexLiteral}
+protected class RegexLiteral_RegexLiteralAction_0 extends ActionToken {
+
+ public RegexLiteral_RegexLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Action getGrammarElement() {
+ return grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(!eObjectConsumer.isConsumed()) return null;
+ return eObjectConsumer;
+ }
+}
+
+// REGEX
+protected class RegexLiteral_REGEXTerminalRuleCall_1 extends UnassignedTextToken {
+
+ public RegexLiteral_REGEXTerminalRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RegexLiteral_RegexLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+/************ end Rule RegexLiteral ****************/
+
+
+/************ begin Rule Literal ****************
+ *
+ * Literal:
+ * NumberLiteral | StringLiteral | BoolLiteral | JSLiteral | RegexLiteral;
+ *
+ **/
+
+// NumberLiteral | StringLiteral | BoolLiteral | JSLiteral | RegexLiteral
+protected class Literal_Alternatives extends AlternativesToken {
+
+ public Literal_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Literal_NumberLiteralParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Literal_StringLiteralParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
+ case 2: return new Literal_BoolLiteralParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
+ case 3: return new Literal_JSLiteralParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
+ case 4: return new Literal_RegexLiteralParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier() &&
+ getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// NumberLiteral
+protected class Literal_NumberLiteralParserRuleCall_0 extends RuleCallToken {
+
+ public Literal_NumberLiteralParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new NumberLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(NumberLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// StringLiteral
+protected class Literal_StringLiteralParserRuleCall_1 extends RuleCallToken {
+
+ public Literal_StringLiteralParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new StringLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getStringLiteralAccess().getStringLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(StringLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// BoolLiteral
+protected class Literal_BoolLiteralParserRuleCall_2 extends RuleCallToken {
+
+ public Literal_BoolLiteralParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new BoolLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(BoolLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// JSLiteral
+protected class Literal_JSLiteralParserRuleCall_3 extends RuleCallToken {
+
+ public Literal_JSLiteralParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new JSLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getJSLiteralAccess().getJSLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(JSLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+// RegexLiteral
+protected class Literal_RegexLiteralParserRuleCall_4 extends RuleCallToken {
+
+ public Literal_RegexLiteralParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new RegexLiteral_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0().getType().getClassifier())
+ return null;
+ if(checkForRecursion(RegexLiteral_Group.class, eObjectConsumer)) return null;
+ return eObjectConsumer;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
+ }
+ }
+}
+
+
+/************ end Rule Literal ****************/
+
+
+/************ begin Rule Parenthetical ****************
+ *
+ * Parenthetical:
+ * => (LPAREN INDENT) content=Body OUTDENT RPAREN | LPAREN content=Body RPAREN;
+ *
+ **/
+
+// => (LPAREN INDENT) content=Body OUTDENT RPAREN | LPAREN content=Body RPAREN
+protected class Parenthetical_Alternatives extends AlternativesToken {
+
+ public Parenthetical_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Alternatives getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getAlternatives();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_Group_0(lastRuleCallOrigin, this, 0, inst);
+ case 1: return new Parenthetical_Group_1(lastRuleCallOrigin, this, 1, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if(getEObject().eClass() != grammarAccess.getParentheticalRule().getType().getClassifier())
+ return null;
+ return eObjectConsumer;
+ }
+
+}
+
+// => (LPAREN INDENT) content=Body OUTDENT RPAREN
+protected class Parenthetical_Group_0 extends GroupToken {
+
+ public Parenthetical_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getGroup_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_RPARENTerminalRuleCall_0_3(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => (LPAREN INDENT)
+protected class Parenthetical_Group_0_0 extends GroupToken {
+
+ public Parenthetical_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getGroup_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_Group_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LPAREN INDENT
+protected class Parenthetical_Group_0_0_0 extends GroupToken {
+
+ public Parenthetical_Group_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getGroup_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_INDENTTerminalRuleCall_0_0_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// LPAREN
+protected class Parenthetical_LPARENTerminalRuleCall_0_0_0_0 extends UnassignedTextToken {
+
+ public Parenthetical_LPARENTerminalRuleCall_0_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// INDENT
+protected class Parenthetical_INDENTTerminalRuleCall_0_0_0_1 extends UnassignedTextToken {
+
+ public Parenthetical_INDENTTerminalRuleCall_0_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_LPARENTerminalRuleCall_0_0_0_0(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+// content=Body
+protected class Parenthetical_ContentAssignment_0_1 extends AssignmentToken {
+
+ public Parenthetical_ContentAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getContentAssignment_0_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("content",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("content");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBodyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Parenthetical_Group_0_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// OUTDENT
+protected class Parenthetical_OUTDENTTerminalRuleCall_0_2 extends UnassignedTextToken {
+
+ public Parenthetical_OUTDENTTerminalRuleCall_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_ContentAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// RPAREN
+protected class Parenthetical_RPARENTerminalRuleCall_0_3 extends UnassignedTextToken {
+
+ public Parenthetical_RPARENTerminalRuleCall_0_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_OUTDENTTerminalRuleCall_0_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+// => LPAREN content=Body RPAREN
+protected class Parenthetical_Group_1 extends GroupToken {
+
+ public Parenthetical_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Group getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getGroup_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_RPARENTerminalRuleCall_1_2(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+// => LPAREN
+protected class Parenthetical_LPARENTerminalRuleCall_1_0 extends UnassignedTextToken {
+
+ public Parenthetical_LPARENTerminalRuleCall_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
+ }
+ }
+
+}
+
+// content=Body
+protected class Parenthetical_ContentAssignment_1_1 extends AssignmentToken {
+
+ public Parenthetical_ContentAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public Assignment getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getContentAssignment_1_1();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Body_Group(this, this, 0, inst);
+ default: return null;
+ }
+ }
+
+ @Override
+ public IEObjectConsumer tryConsume() {
+ if((value = eObjectConsumer.getConsumable("content",true)) == null) return null;
+ IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("content");
+ if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
+ IEObjectConsumer param = createEObjectConsumer((EObject)value);
+ if(param.isInstanceOf(grammarAccess.getBodyRule().getType().getClassifier())) {
+ type = AssignmentType.PARSER_RULE_CALL;
+ element = grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0();
+ consumed = obj;
+ return param;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public AbstractToken createFollowerAfterReturn(AbstractToken next, int actIndex, int index, IEObjectConsumer inst) {
+ if(value == inst.getEObject() && !inst.isConsumed()) return null;
+ switch(index) {
+ case 0: return new Parenthetical_LPARENTerminalRuleCall_1_0(lastRuleCallOrigin, next, actIndex, consumed);
+ default: return null;
+ }
+ }
+}
+
+// RPAREN
+protected class Parenthetical_RPARENTerminalRuleCall_1_2 extends UnassignedTextToken {
+
+ public Parenthetical_RPARENTerminalRuleCall_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
+ super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
+ }
+
+ @Override
+ public RuleCall getGrammarElement() {
+ return grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2();
+ }
+
+ @Override
+ public AbstractToken createFollower(int index, IEObjectConsumer inst) {
+ switch(index) {
+ case 0: return new Parenthetical_ContentAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
+ default: return null;
+ }
+ }
+
+}
+
+
+
+/************ end Rule Parenthetical ****************/
+
+}
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/CakefileAntlrTokenFileProvider.java b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/CakefileAntlrTokenFileProvider.java
new file mode 100644
index 0000000..05ffb94
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/CakefileAntlrTokenFileProvider.java
@@ -0,0 +1,15 @@
+/*
+* generated by Xtext
+*/
+package csep.example.cake.parser.antlr;
+
+import java.io.InputStream;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+
+public class CakefileAntlrTokenFileProvider implements IAntlrTokenFileProvider {
+
+ public InputStream getAntlrTokenFile() {
+ ClassLoader classLoader = getClass().getClassLoader();
+ return classLoader.getResourceAsStream("csep/example/cake/parser/antlr/internal/InternalCakefile.tokens");
+ }
+}
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/CakefileParser.java b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/CakefileParser.java
new file mode 100644
index 0000000..5402dc5
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/CakefileParser.java
@@ -0,0 +1,39 @@
+/*
+* generated by Xtext
+*/
+package csep.example.cake.parser.antlr;
+
+import com.google.inject.Inject;
+
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import csep.example.cake.services.CakefileGrammarAccess;
+
+public class CakefileParser extends org.eclipse.xtext.parser.antlr.AbstractAntlrParser {
+
+ @Inject
+ private CakefileGrammarAccess grammarAccess;
+
+ @Override
+ protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
+ tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
+ }
+
+ @Override
+ protected csep.example.cake.parser.antlr.internal.InternalCakefileParser createParser(XtextTokenStream stream) {
+ return new csep.example.cake.parser.antlr.internal.InternalCakefileParser(stream, getGrammarAccess());
+ }
+
+ @Override
+ protected String getDefaultRuleName() {
+ return "Cakefile";
+ }
+
+ public CakefileGrammarAccess getGrammarAccess() {
+ return this.grammarAccess;
+ }
+
+ public void setGrammarAccess(CakefileGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+
+}
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g
new file mode 100644
index 0000000..8c47719
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g
@@ -0,0 +1,5685 @@
+/*
+* generated by Xtext
+*/
+grammar InternalCakefile;
+
+options {
+ superClass=AbstractInternalAntlrParser;
+
+}
+
+@lexer::header {
+package csep.example.cake.parser.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.parser.antlr.Lexer;
+}
+
+@parser::header {
+package csep.example.cake.parser.antlr.internal;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import csep.example.cake.services.CakefileGrammarAccess;
+
+}
+
+@parser::members {
+
+ private CakefileGrammarAccess grammarAccess;
+
+ public InternalCakefileParser(TokenStream input, CakefileGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "Cakefile";
+ }
+
+ @Override
+ protected CakefileGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+}
+
+@rulecatch {
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+}
+
+
+
+
+// Entry rule entryRuleCakefile
+entryRuleCakefile returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCakefileRule()); }
+ iv_ruleCakefile=ruleCakefile
+ { $current=$iv_ruleCakefile.current; }
+ EOF
+;
+
+// Rule Cakefile
+ruleCakefile returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getCakefileAccess().getTasksTaskDeclarationParserRuleCall_0());
+ }
+ lv_tasks_0_0=ruleTaskDeclaration {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCakefileRule());
+ }
+ add(
+ $current,
+ "tasks",
+ lv_tasks_0_0,
+ "TaskDeclaration");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*
+;
+
+
+
+
+
+// Entry rule entryRuleTaskDeclaration
+entryRuleTaskDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTaskDeclarationRule()); }
+ iv_ruleTaskDeclaration=ruleTaskDeclaration
+ { $current=$iv_ruleTaskDeclaration.current; }
+ EOF
+;
+
+// Rule TaskDeclaration
+ruleTaskDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(this_TASK_0=RULE_TASK
+ {
+ newLeafNode(this_TASK_0, grammarAccess.getTaskDeclarationAccess().getTASKTerminalRuleCall_0());
+ }
+this_CALL_START_1=RULE_CALL_START
+ {
+ newLeafNode(this_CALL_START_1, grammarAccess.getTaskDeclarationAccess().getCALL_STARTTerminalRuleCall_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTaskDeclarationAccess().getNameStringLiteralParserRuleCall_2_0());
+ }
+ lv_name_2_0=ruleStringLiteral {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTaskDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_2_0,
+ "StringLiteral");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_COMMA_3=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_3, grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_3());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTaskDeclarationAccess().getDescriptionStringLiteralParserRuleCall_4_0());
+ }
+ lv_description_4_0=ruleStringLiteral {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTaskDeclarationRule());
+ }
+ set(
+ $current,
+ "description",
+ lv_description_4_0,
+ "StringLiteral");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_COMMA_5=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_5, grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_5());
+ }
+(this_PARAM_START_6=RULE_PARAM_START
+ {
+ newLeafNode(this_PARAM_START_6, grammarAccess.getTaskDeclarationAccess().getPARAM_STARTTerminalRuleCall_6_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTaskDeclarationAccess().getOptionsIdParserRuleCall_6_1_0());
+ }
+ lv_options_7_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTaskDeclarationRule());
+ }
+ set(
+ $current,
+ "options",
+ lv_options_7_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_PARAM_END_8=RULE_PARAM_END
+ {
+ newLeafNode(this_PARAM_END_8, grammarAccess.getTaskDeclarationAccess().getPARAM_ENDTerminalRuleCall_6_2());
+ }
+)?this_FUNC_ARROW_9=RULE_FUNC_ARROW
+ {
+ newLeafNode(this_FUNC_ARROW_9, grammarAccess.getTaskDeclarationAccess().getFUNC_ARROWTerminalRuleCall_7());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getTaskDeclarationAccess().getBodyBlockParserRuleCall_8_0());
+ }
+ lv_body_10_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTaskDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_10_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_CALL_END_11=RULE_CALL_END
+ {
+ newLeafNode(this_CALL_END_11, grammarAccess.getTaskDeclarationAccess().getCALL_ENDTerminalRuleCall_9());
+ }
+this_TERMINATOR_12=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_12, grammarAccess.getTaskDeclarationAccess().getTERMINATORTerminalRuleCall_10());
+ }
+)
+;
+
+
+
+
+
+
+
+// Entry rule entryRuleBody
+entryRuleBody returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBodyRule()); }
+ iv_ruleBody=ruleBody
+ { $current=$iv_ruleBody.current; }
+ EOF
+;
+
+// Rule Body
+ruleBody returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0());
+ }
+ lv_lines_0_0=ruleLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBodyRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_0_0,
+ "Line");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_TERMINATOR_1=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0());
+ }
+ lv_lines_2_0=ruleLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBodyRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_2_0,
+ "Line");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)*)
+;
+
+
+
+
+
+// Entry rule entryRuleLine
+entryRuleLine returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLineRule()); }
+ iv_ruleLine=ruleLine
+ { $current=$iv_ruleLine.current; }
+ EOF
+;
+
+// Rule Line
+ruleLine returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getLineAccess().getStmtParserRuleCall_0());
+ }
+ this_Stmt_0=ruleStmt
+ {
+ $current = $this_Stmt_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLineAccess().getExpressionParserRuleCall_1());
+ }
+ this_Expression_1=ruleExpression
+ {
+ $current = $this_Expression_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleStmt
+entryRuleStmt returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStmtRule()); }
+ iv_ruleStmt=ruleStmt
+ { $current=$iv_ruleStmt.current; }
+ EOF
+;
+
+// Rule Stmt
+ruleStmt returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0());
+ }
+ this_ReturnStmt_0=ruleReturnStmt
+ {
+ $current = $this_ReturnStmt_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1());
+ }
+ this_ThrowStmt_1=ruleThrowStmt
+ {
+ $current = $this_ThrowStmt_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((((
+(
+ruleId
+)
+) RULE_EQUAL 'require'
+))=>
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2());
+ }
+ this_RequireStmt_2=ruleRequireStmt
+ {
+ $current = $this_RequireStmt_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getCommentParserRuleCall_3());
+ }
+ this_Comment_3=ruleComment
+ {
+ $current = $this_Comment_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4());
+ }
+ this_ClassDeclaration_4=ruleClassDeclaration
+ {
+ $current = $this_ClassDeclaration_4.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |(
+(
+ lv_statement_5_0=RULE_STATEMENT
+ {
+ newLeafNode(lv_statement_5_0, grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getStmtRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "statement",
+ lv_statement_5_0,
+ "STATEMENT");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleComment
+entryRuleComment returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCommentRule()); }
+ iv_ruleComment=ruleComment
+ { $current=$iv_ruleComment.current; }
+ EOF
+;
+
+// Rule Comment
+ruleComment returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ lv_comment_0_0=RULE_HERECOMMENT
+ {
+ newLeafNode(lv_comment_0_0, grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getCommentRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "comment",
+ lv_comment_0_0,
+ "HERECOMMENT");
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleRequireStmt
+entryRuleRequireStmt returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRequireStmtRule()); }
+ iv_ruleRequireStmt=ruleRequireStmt
+ { $current=$iv_ruleRequireStmt.current; }
+ EOF
+;
+
+// Rule RequireStmt
+ruleRequireStmt returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((((
+(
+ruleId
+)
+) RULE_EQUAL 'require'
+))=>((
+(
+ {
+ newCompositeNode(grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0());
+ }
+ lv_importedNamespace_0_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRequireStmtRule());
+ }
+ set(
+ $current,
+ "importedNamespace",
+ lv_importedNamespace_0_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_EQUAL_1=RULE_EQUAL
+ {
+ newLeafNode(this_EQUAL_1, grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1());
+ }
+ otherlv_2='require'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2());
+ }
+))this_CALL_START_3=RULE_CALL_START
+ {
+ newLeafNode(this_CALL_START_3, grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1());
+ }
+(
+(
+ lv_uri_4_0=RULE_STRING
+ {
+ newLeafNode(lv_uri_4_0, grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRequireStmtRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "uri",
+ lv_uri_4_0,
+ "STRING");
+ }
+
+)
+)this_CALL_END_5=RULE_CALL_END
+ {
+ newLeafNode(this_CALL_END_5, grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleReturnStmt
+entryRuleReturnStmt returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getReturnStmtRule()); }
+ iv_ruleReturnStmt=ruleReturnStmt
+ { $current=$iv_ruleReturnStmt.current; }
+ EOF
+;
+
+// Rule ReturnStmt
+ruleReturnStmt returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getReturnStmtAccess().getReturnStmtAction_0(),
+ $current);
+ }
+)this_RETURN_1=RULE_RETURN
+ {
+ newLeafNode(this_RETURN_1, grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0());
+ }
+ lv_expression_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getReturnStmtRule());
+ }
+ set(
+ $current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(this_POST_IF_3=RULE_POST_IF
+ {
+ newLeafNode(this_POST_IF_3, grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0());
+ }
+ lv_condition_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getReturnStmtRule());
+ }
+ set(
+ $current,
+ "condition",
+ lv_condition_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleThrowStmt
+entryRuleThrowStmt returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getThrowStmtRule()); }
+ iv_ruleThrowStmt=ruleThrowStmt
+ { $current=$iv_ruleThrowStmt.current; }
+ EOF
+;
+
+// Rule ThrowStmt
+ruleThrowStmt returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(this_THROW_0=RULE_THROW
+ {
+ newLeafNode(this_THROW_0, grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0());
+ }
+ lv_exp_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getThrowStmtRule());
+ }
+ set(
+ $current,
+ "exp",
+ lv_exp_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSuperClass
+entryRuleSuperClass returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSuperClassRule()); }
+ iv_ruleSuperClass=ruleSuperClass
+ { $current=$iv_ruleSuperClass.current; }
+ EOF
+;
+
+// Rule SuperClass
+ruleSuperClass returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0());
+ }
+ this_IdRef_0=ruleIdRef
+ {
+ $current = $this_IdRef_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1());
+ }
+ this_Property_1=ruleProperty
+ {
+ $current = $this_Property_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleClassDeclaration
+entryRuleClassDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getClassDeclarationRule()); }
+ iv_ruleClassDeclaration=ruleClassDeclaration
+ { $current=$iv_ruleClassDeclaration.current; }
+ EOF
+;
+
+// Rule ClassDeclaration
+ruleClassDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0(),
+ $current);
+ }
+)this_CLASS_1=RULE_CLASS
+ {
+ newLeafNode(this_CLASS_1, grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0());
+ }
+ lv_body_2_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(this_EXTENDS_3=RULE_EXTENDS
+ {
+ newLeafNode(this_EXTENDS_3, grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0());
+ }
+ lv_extend_4_0=ruleSuperClass {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "extend",
+ lv_extend_4_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+ }
+ lv_body_5_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_5_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+ |((
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0());
+ }
+ lv_name_6_1=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_6_1,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+ | {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1());
+ }
+ lv_name_6_2=ruleProperty {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_6_2,
+ "Property");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+
+)
+)(this_EXTENDS_7=RULE_EXTENDS
+ {
+ newLeafNode(this_EXTENDS_7, grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0());
+ }
+ lv_extend_8_0=ruleSuperClass {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "extend",
+ lv_extend_8_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0());
+ }
+ lv_body_9_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_9_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignedClassDeclaration
+entryRuleAssignedClassDeclaration returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignedClassDeclarationRule()); }
+ iv_ruleAssignedClassDeclaration=ruleAssignedClassDeclaration
+ { $current=$iv_ruleAssignedClassDeclaration.current; }
+ EOF
+;
+
+// Rule AssignedClassDeclaration
+ruleAssignedClassDeclaration returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0(),
+ $current);
+ }
+)this_CLASS_1=RULE_CLASS
+ {
+ newLeafNode(this_CLASS_1, grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+ }
+((this_EXTENDS_2=RULE_EXTENDS
+ {
+ newLeafNode(this_EXTENDS_2, grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0());
+ }
+ lv_extend_3_0=ruleSuperClass {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "extend",
+ lv_extend_3_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0());
+ }
+ lv_body_4_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0());
+ }
+ lv_name_5_1=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_5_1,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+ | {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1());
+ }
+ lv_name_5_2=ruleProperty {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_5_2,
+ "Property");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+
+)
+)(this_EXTENDS_6=RULE_EXTENDS
+ {
+ newLeafNode(this_EXTENDS_6, grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0());
+ }
+ lv_extend_7_0=ruleSuperClass {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "extend",
+ lv_extend_7_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+ }
+ lv_body_8_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_8_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleExpression
+entryRuleExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExpressionRule()); }
+ iv_ruleExpression=ruleExpression
+ { $current=$iv_ruleExpression.current; }
+ EOF
+;
+
+// Rule Expression
+ruleExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ {
+ newCompositeNode(grammarAccess.getExpressionAccess().getPostfixParserRuleCall());
+ }
+ this_Postfix_0=rulePostfix
+ {
+ $current = $this_Postfix_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+;
+
+
+
+
+
+// Entry rule entryRulePostfix
+entryRulePostfix returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPostfixRule()); }
+ iv_rulePostfix=rulePostfix
+ { $current=$iv_rulePostfix.current; }
+ EOF
+;
+
+// Rule Postfix
+rulePostfix returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0());
+ }
+ this_Assignment_0=ruleAssignment
+ {
+ $current = $this_Assignment_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((( RULE_POST_IF)=>this_POST_IF_1=RULE_POST_IF
+ {
+ newLeafNode(this_POST_IF_1, grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0());
+ }
+)(
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0());
+ }
+ lv_condition_3_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "condition",
+ lv_condition_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((( RULE_FOR)=>this_FOR_4=RULE_FOR
+ {
+ newLeafNode(this_FOR_4, grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0());
+ }
+)(
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getForDummyAction_1_1_1(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0());
+ }
+ lv_body_6_0=ruleForBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_6_0,
+ "ForBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((( RULE_WHILE)=>this_WHILE_7=RULE_WHILE
+ {
+ newLeafNode(this_WHILE_7, grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0());
+ }
+)(
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0());
+ }
+ lv_body_9_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_9_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_WHEN)=>this_WHEN_10=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_10, grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0());
+ }
+ lv_when_11_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_11_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |((( RULE_UNTIL)=>this_UNTIL_12=RULE_UNTIL
+ {
+ newLeafNode(this_UNTIL_12, grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0());
+ }
+)(
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0());
+ }
+ lv_body_14_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_14_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_WHEN)=>this_WHEN_15=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_15, grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0());
+ }
+ lv_when_16_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_16_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?))?)
+;
+
+
+
+
+
+// Entry rule entryRuleForBody
+entryRuleForBody returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getForBodyRule()); }
+ iv_ruleForBody=ruleForBody
+ { $current=$iv_ruleForBody.current; }
+ EOF
+;
+
+// Rule ForBody
+ruleForBody returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((this_OWN_0=RULE_OWN
+ {
+ newLeafNode(this_OWN_0, grammarAccess.getForBodyAccess().getOWNTerminalRuleCall_0());
+ }
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0());
+ }
+ lv_indexes_1_0=ruleForValue {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ add(
+ $current,
+ "indexes",
+ lv_indexes_1_0,
+ "ForValue");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_2=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_2, grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0());
+ }
+ lv_indexes_3_0=ruleForValue {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ add(
+ $current,
+ "indexes",
+ lv_indexes_3_0,
+ "ForValue");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(
+(
+ {
+ newCompositeNode(grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0());
+ }
+ lv_source_4_0=ruleForSource {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_4_0,
+ "ForSource");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleForValue
+entryRuleForValue returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getForValueRule()); }
+ iv_ruleForValue=ruleForValue
+ { $current=$iv_ruleForValue.current; }
+ EOF
+;
+
+// Rule ForValue
+ruleForValue returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+
+ {
+ newCompositeNode(grammarAccess.getForValueAccess().getIdParserRuleCall());
+ }
+ this_Id_0=ruleId
+ {
+ $current = $this_Id_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+;
+
+
+
+
+
+// Entry rule entryRuleForSource
+entryRuleForSource returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getForSourceRule()); }
+ iv_ruleForSource=ruleForSource
+ { $current=$iv_ruleForSource.current; }
+ EOF
+;
+
+// Rule ForSource
+ruleForSource returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getForSourceAccess().getForSourceAction_0(),
+ $current);
+ }
+)(((( RULE_FOROF)=>this_FOROF_1=RULE_FOROF
+ {
+ newLeafNode(this_FOROF_1, grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0());
+ }
+ lv_source_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_WHEN)=>this_WHEN_3=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_3, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0());
+ }
+ lv_when_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |((( RULE_FORIN)=>this_FORIN_5=RULE_FORIN
+ {
+ newLeafNode(this_FORIN_5, grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0());
+ }
+ lv_source_6_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "source",
+ lv_source_6_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(((( RULE_WHEN)=>this_WHEN_7=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_7, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0());
+ }
+ lv_when_8_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_8_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_BY)=>this_BY_9=RULE_BY
+ {
+ newLeafNode(this_BY_9, grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0());
+ }
+ lv_by_10_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "by",
+ lv_by_10_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |((( RULE_BY)=>this_BY_11=RULE_BY
+ {
+ newLeafNode(this_BY_11, grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0());
+ }
+ lv_by_12_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "by",
+ lv_by_12_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((( RULE_WHEN)=>this_WHEN_13=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_13, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0());
+ }
+ lv_when_14_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_14_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?))?)))
+;
+
+
+
+
+
+// Entry rule entryRuleRange
+entryRuleRange returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRangeRule()); }
+ iv_ruleRange=ruleRange
+ { $current=$iv_ruleRange.current; }
+ EOF
+;
+
+// Rule Range
+ruleRange returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((( RULE_LBRACKET(
+(
+ruleExpression
+)
+)( RULE_DOT_DOT
+ | RULE_ELLIPSIS)))=>(this_LBRACKET_0=RULE_LBRACKET
+ {
+ newLeafNode(this_LBRACKET_0, grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0());
+ }
+ lv_start_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRangeRule());
+ }
+ set(
+ $current,
+ "start",
+ lv_start_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_DOT_DOT_2=RULE_DOT_DOT
+ {
+ newLeafNode(this_DOT_DOT_2, grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0());
+ }
+
+ |this_ELLIPSIS_3=RULE_ELLIPSIS
+ {
+ newLeafNode(this_ELLIPSIS_3, grammarAccess.getRangeAccess().getELLIPSISTerminalRuleCall_0_0_2_1());
+ }
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0());
+ }
+ lv_end_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRangeRule());
+ }
+ set(
+ $current,
+ "end",
+ lv_end_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_RBRACKET_5=RULE_RBRACKET
+ {
+ newLeafNode(this_RBRACKET_5, grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignment
+entryRuleAssignment returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignmentRule()); }
+ iv_ruleAssignment=ruleAssignment
+ { $current=$iv_ruleAssignment.current; }
+ EOF
+;
+
+// Rule Assignment
+ruleAssignment returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((((
+(
+ruleAssignable
+)
+)(
+(
+(
+RULE_EQUAL
+
+ | RULE_COMPOUND_ASSIGN
+
+)
+
+)
+)))=>((
+(
+ {
+ newCompositeNode(grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0());
+ }
+ lv_left_0_0=ruleAssignable {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignmentRule());
+ }
+ set(
+ $current,
+ "left",
+ lv_left_0_0,
+ "Assignable");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+(
+ lv_operator_1_1=RULE_EQUAL
+ {
+ newLeafNode(lv_operator_1_1, grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAssignmentRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_1_1,
+ "EQUAL");
+ }
+
+ | lv_operator_1_2=RULE_COMPOUND_ASSIGN
+ {
+ newLeafNode(lv_operator_1_2, grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAssignmentRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_1_2,
+ "COMPOUND_ASSIGN");
+ }
+
+)
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0());
+ }
+ lv_right_2_0=ruleAssigned {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignmentRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_2_0,
+ "Assigned");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |
+ {
+ newCompositeNode(grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1());
+ }
+ this_LogicOp_3=ruleLogicOp
+ {
+ $current = $this_LogicOp_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAssigned
+entryRuleAssigned returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignedRule()); }
+ iv_ruleAssigned=ruleAssigned
+ { $current=$iv_ruleAssigned.current; }
+ EOF
+;
+
+// Rule Assigned
+ruleAssigned returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0());
+ }
+ this_Expression_0=ruleExpression
+ {
+ $current = $this_Expression_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |(this_INDENT_1=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_1, grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0());
+ }
+
+ {
+ newCompositeNode(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1());
+ }
+ this_Expression_2=ruleExpression
+ {
+ $current = $this_Expression_2.current;
+ afterParserOrEnumRuleCall();
+ }
+this_OUTDENT_3=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_3, grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2());
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2());
+ }
+ this_AssignedClassDeclaration_4=ruleAssignedClassDeclaration
+ {
+ $current = $this_AssignedClassDeclaration_4.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleLogicOp
+entryRuleLogicOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLogicOpRule()); }
+ iv_ruleLogicOp=ruleLogicOp
+ { $current=$iv_ruleLogicOp.current; }
+ EOF
+;
+
+// Rule LogicOp
+ruleLogicOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0());
+ }
+ this_CompareOp_0=ruleCompareOp
+ {
+ $current = $this_CompareOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_LOGIC
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_LOGIC
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getLogicOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "LOGIC");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleCompareOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLogicOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "CompareOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleCompareOp
+entryRuleCompareOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCompareOpRule()); }
+ iv_ruleCompareOp=ruleCompareOp
+ { $current=$iv_ruleCompareOp.current; }
+ EOF
+;
+
+// Rule CompareOp
+ruleCompareOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0());
+ }
+ this_RelationOp_0=ruleRelationOp
+ {
+ $current = $this_RelationOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_COMPARE
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_COMPARE
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getCompareOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "COMPARE");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleRelationOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCompareOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "RelationOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleRelationOp
+entryRuleRelationOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRelationOpRule()); }
+ iv_ruleRelationOp=ruleRelationOp
+ { $current=$iv_ruleRelationOp.current; }
+ EOF
+;
+
+// Rule RelationOp
+ruleRelationOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0());
+ }
+ this_ShiftOp_0=ruleShiftOp
+ {
+ $current = $this_ShiftOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_RELATION
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_RELATION
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRelationOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "RELATION");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleShiftOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRelationOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "ShiftOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleShiftOp
+entryRuleShiftOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getShiftOpRule()); }
+ iv_ruleShiftOp=ruleShiftOp
+ { $current=$iv_ruleShiftOp.current; }
+ EOF
+;
+
+// Rule ShiftOp
+ruleShiftOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0());
+ }
+ this_AdditiveOp_0=ruleAdditiveOp
+ {
+ $current = $this_AdditiveOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_SHIFT
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_SHIFT
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getShiftOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "SHIFT");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleAdditiveOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getShiftOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "AdditiveOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleAdditiveOp
+entryRuleAdditiveOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAdditiveOpRule()); }
+ iv_ruleAdditiveOp=ruleAdditiveOp
+ { $current=$iv_ruleAdditiveOp.current; }
+ EOF
+;
+
+// Rule AdditiveOp
+ruleAdditiveOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0());
+ }
+ this_MathOp_0=ruleMathOp
+ {
+ $current = $this_MathOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+(
+RULE_PLUS
+
+ | RULE_MINUS
+
+)
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+(
+ lv_operator_2_1=RULE_PLUS
+ {
+ newLeafNode(lv_operator_2_1, grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAdditiveOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_1,
+ "PLUS");
+ }
+
+ | lv_operator_2_2=RULE_MINUS
+ {
+ newLeafNode(lv_operator_2_2, grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAdditiveOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_2,
+ "MINUS");
+ }
+
+)
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleMathOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAdditiveOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "MathOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleMathOp
+entryRuleMathOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getMathOpRule()); }
+ iv_ruleMathOp=ruleMathOp
+ { $current=$iv_ruleMathOp.current; }
+ EOF
+;
+
+// Rule MathOp
+ruleMathOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0());
+ }
+ this_UnaryOp_0=ruleUnaryOp
+ {
+ $current = $this_UnaryOp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(((((
+)(
+(
+RULE_MATH
+
+)
+)))=>((
+ {
+ $current = forceCreateModelElementAndSet(
+ grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ $current);
+ }
+)(
+(
+ lv_operator_2_0=RULE_MATH
+ {
+ newLeafNode(lv_operator_2_0, grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getMathOpRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_2_0,
+ "MATH");
+ }
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0());
+ }
+ lv_right_3_0=ruleUnaryOp {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMathOpRule());
+ }
+ set(
+ $current,
+ "right",
+ lv_right_3_0,
+ "UnaryOp");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleUnaryOp
+entryRuleUnaryOp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getUnaryOpRule()); }
+ iv_ruleUnaryOp=ruleUnaryOp
+ { $current=$iv_ruleUnaryOp.current; }
+ EOF
+;
+
+// Rule UnaryOp
+ruleUnaryOp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((this_UNARY_0=RULE_UNARY
+ {
+ newLeafNode(this_UNARY_0, grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0());
+ }
+
+ |this_PLUS_1=RULE_PLUS
+ {
+ newLeafNode(this_PLUS_1, grammarAccess.getUnaryOpAccess().getPLUSTerminalRuleCall_0_0_1());
+ }
+
+ |this_MINUS_2=RULE_MINUS
+ {
+ newLeafNode(this_MINUS_2, grammarAccess.getUnaryOpAccess().getMINUSTerminalRuleCall_0_0_2());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1());
+ }
+ this_Expression_3=ruleExpression
+ {
+ $current = $this_Expression_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |((this_PLUS_PLUS_4=RULE_PLUS_PLUS
+ {
+ newLeafNode(this_PLUS_PLUS_4, grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0());
+ }
+
+ |this_MINUS_MINUS_5=RULE_MINUS_MINUS
+ {
+ newLeafNode(this_MINUS_MINUS_5, grammarAccess.getUnaryOpAccess().getMINUS_MINUSTerminalRuleCall_1_0_1());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1());
+ }
+ this_Variable_6=ruleVariable
+ {
+ $current = $this_Variable_6.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(
+ {
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0());
+ }
+ this_Application_7=ruleApplication
+ {
+ $current = $this_Application_7.current;
+ afterParserOrEnumRuleCall();
+ }
+(this_QUESTION_8=RULE_QUESTION
+ {
+ newLeafNode(this_QUESTION_8, grammarAccess.getUnaryOpAccess().getQUESTIONTerminalRuleCall_2_1());
+ }
+)?))
+;
+
+
+
+
+
+// Entry rule entryRuleApplication
+entryRuleApplication returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getApplicationRule()); }
+ iv_ruleApplication=ruleApplication
+ { $current=$iv_ruleApplication.current; }
+ EOF
+;
+
+// Rule Application
+ruleApplication returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getApplicationAccess().getSuperCallAction_0_0(),
+ $current);
+ }
+)(this_SUPER_1=RULE_SUPER
+ {
+ newLeafNode(this_SUPER_1, grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0());
+ }
+(this_CALL_START_2=RULE_CALL_START
+ {
+ newLeafNode(this_CALL_START_2, grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0());
+ }
+ lv_args_3_0=ruleArgList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ set(
+ $current,
+ "args",
+ lv_args_3_0,
+ "ArgList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_CALL_END_4=RULE_CALL_END
+ {
+ newLeafNode(this_CALL_END_4, grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2());
+ }
+)?))
+ |((
+(
+ {
+ newCompositeNode(grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0());
+ }
+ lv_value_5_0=rulePrimaryExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_5_0,
+ "PrimaryExpression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0());
+ }
+ lv_features_6_0=ruleFeatureCall {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ add(
+ $current,
+ "features",
+ lv_features_6_0,
+ "FeatureCall");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*))
+;
+
+
+
+
+
+// Entry rule entryRuleFeatureCall
+entryRuleFeatureCall returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFeatureCallRule()); }
+ iv_ruleFeatureCall=ruleFeatureCall
+ { $current=$iv_ruleFeatureCall.current; }
+ EOF
+;
+
+// Rule FeatureCall
+ruleFeatureCall returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0());
+ }
+ this_FunctionCall_0=ruleFunctionCall
+ {
+ $current = $this_FunctionCall_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1());
+ }
+ this_PropertyAccess_1=rulePropertyAccess
+ {
+ $current = $this_PropertyAccess_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleFunctionCall
+entryRuleFunctionCall returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getFunctionCallRule()); }
+ iv_ruleFunctionCall=ruleFunctionCall
+ { $current=$iv_ruleFunctionCall.current; }
+ EOF
+;
+
+// Rule FunctionCall
+ruleFunctionCall returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getFunctionCallAccess().getFunctionCallAction_0(),
+ $current);
+ }
+)(this_FUNC_EXIST_1=RULE_FUNC_EXIST
+ {
+ newLeafNode(this_FUNC_EXIST_1, grammarAccess.getFunctionCallAccess().getFUNC_EXISTTerminalRuleCall_1());
+ }
+)?this_CALL_START_2=RULE_CALL_START
+ {
+ newLeafNode(this_CALL_START_2, grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0());
+ }
+ lv_args_3_0=ruleArgList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getFunctionCallRule());
+ }
+ set(
+ $current,
+ "args",
+ lv_args_3_0,
+ "ArgList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_CALL_END_4=RULE_CALL_END
+ {
+ newLeafNode(this_CALL_END_4, grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRulePropertyAccess
+entryRulePropertyAccess returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyAccessRule()); }
+ iv_rulePropertyAccess=rulePropertyAccess
+ { $current=$iv_rulePropertyAccess.current; }
+ EOF
+;
+
+// Rule PropertyAccess
+rulePropertyAccess returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0());
+ }
+ this_NamedPropertyAccess_0=ruleNamedPropertyAccess
+ {
+ $current = $this_NamedPropertyAccess_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1());
+ }
+ this_IndexedPropertyAccess_1=ruleIndexedPropertyAccess
+ {
+ $current = $this_IndexedPropertyAccess_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleThisProperty
+entryRuleThisProperty returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getThisPropertyRule()); }
+ iv_ruleThisProperty=ruleThisProperty
+ { $current=$iv_ruleThisProperty.current; }
+ EOF
+;
+
+// Rule ThisProperty
+ruleThisProperty returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(this_AT_SIGIL_0=RULE_AT_SIGIL
+ {
+ newLeafNode(this_AT_SIGIL_0, grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0());
+ }
+
+ {
+ newCompositeNode(grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1());
+ }
+ this_Id_1=ruleId
+ {
+ $current = $this_Id_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleNamedPropertyAccess
+entryRuleNamedPropertyAccess returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNamedPropertyAccessRule()); }
+ iv_ruleNamedPropertyAccess=ruleNamedPropertyAccess
+ { $current=$iv_ruleNamedPropertyAccess.current; }
+ EOF
+;
+
+// Rule NamedPropertyAccess
+ruleNamedPropertyAccess returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+(
+ lv_accessor_0_1=RULE_DOT
+ {
+ newLeafNode(lv_accessor_0_1, grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_0_1,
+ "DOT");
+ }
+
+ | lv_accessor_0_2=RULE_QUESTION_DOT
+ {
+ newLeafNode(lv_accessor_0_2, grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_0_2,
+ "QUESTION_DOT");
+ }
+
+)
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0());
+ }
+ lv_name_1_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedPropertyAccessRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_1_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |((
+(
+ lv_accessor_2_0=RULE_DOUBLE_COLON
+ {
+ newLeafNode(lv_accessor_2_0, grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_2_0,
+ "DOUBLE_COLON");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0());
+ }
+ lv_name_3_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getNamedPropertyAccessRule());
+ }
+ set(
+ $current,
+ "name",
+ lv_name_3_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?))
+;
+
+
+
+
+
+// Entry rule entryRuleIndexedPropertyAccess
+entryRuleIndexedPropertyAccess returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIndexedPropertyAccessRule()); }
+ iv_ruleIndexedPropertyAccess=ruleIndexedPropertyAccess
+ { $current=$iv_ruleIndexedPropertyAccess.current; }
+ EOF
+;
+
+// Rule IndexedPropertyAccess
+ruleIndexedPropertyAccess returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(this_INDEX_START_0=RULE_INDEX_START
+ {
+ newLeafNode(this_INDEX_START_0, grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0());
+ }
+ lv_index_1_0=ruleIndex {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexedPropertyAccessRule());
+ }
+ set(
+ $current,
+ "index",
+ lv_index_1_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_INDEX_END_2=RULE_INDEX_END
+ {
+ newLeafNode(this_INDEX_END_2, grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleIndex
+entryRuleIndex returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIndexRule()); }
+ iv_ruleIndex=ruleIndex
+ { $current=$iv_ruleIndex.current; }
+ EOF
+;
+
+// Rule Index
+ruleIndex returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((
+(
+(
+RULE_DOT_DOT
+
+ | RULE_ELLIPSIS
+
+)
+
+)
+)=>
+(
+(
+ lv_dots_0_1=RULE_DOT_DOT
+ {
+ newLeafNode(lv_dots_0_1, grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "dots",
+ lv_dots_0_1,
+ "DOT_DOT");
+ }
+
+ | lv_dots_0_2=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_dots_0_2, grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "dots",
+ lv_dots_0_2,
+ "ELLIPSIS");
+ }
+
+)
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0());
+ }
+ lv_end_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ $current,
+ "end",
+ lv_end_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(((((
+(
+ruleExpression
+)
+)(
+(
+(
+RULE_DOT_DOT
+
+ | RULE_ELLIPSIS
+
+)
+
+)
+)))=>((
+(
+ {
+ newCompositeNode(grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0());
+ }
+ lv_start_2_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ $current,
+ "start",
+ lv_start_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+(
+ lv_dots_3_1=RULE_DOT_DOT
+ {
+ newLeafNode(lv_dots_3_1, grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "dots",
+ lv_dots_3_1,
+ "DOT_DOT");
+ }
+
+ | lv_dots_3_2=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_dots_3_2, grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "dots",
+ lv_dots_3_2,
+ "ELLIPSIS");
+ }
+
+)
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0());
+ }
+ lv_end_4_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ $current,
+ "end",
+ lv_end_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0());
+ }
+ lv_exp_5_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ $current,
+ "exp",
+ lv_exp_5_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRulePrimaryExpression
+entryRulePrimaryExpression returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPrimaryExpressionRule()); }
+ iv_rulePrimaryExpression=rulePrimaryExpression
+ { $current=$iv_rulePrimaryExpression.current; }
+ EOF
+;
+
+// Rule PrimaryExpression
+rulePrimaryExpression returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0());
+ }
+ this_IfExp_0=ruleIfExp
+ {
+ $current = $this_IfExp_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1());
+ }
+ this_Parenthetical_1=ruleParenthetical
+ {
+ $current = $this_Parenthetical_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2());
+ }
+ this_Literal_2=ruleLiteral
+ {
+ $current = $this_Literal_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((( RULE_LBRACKET(
+(
+ruleExpression
+)
+)( RULE_DOT_DOT
+ | RULE_ELLIPSIS)))=>
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3());
+ }
+ this_Range_3=ruleRange
+ {
+ $current = $this_Range_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(( RULE_LBRACKET)=>
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4());
+ }
+ this_Array_4=ruleArray
+ {
+ $current = $this_Array_4.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(( RULE_LCURLY)=>
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5());
+ }
+ this_Dictionary_5=ruleDictionary
+ {
+ $current = $this_Dictionary_5.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6());
+ }
+ this_Lambda_6=ruleLambda
+ {
+ $current = $this_Lambda_6.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7());
+ }
+ this_ThisProperty_7=ruleThisProperty
+ {
+ $current = $this_ThisProperty_7.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0(),
+ $current);
+ }
+)this_THIS_9=RULE_THIS
+ {
+ newLeafNode(this_THIS_9, grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1());
+ }
+)
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getForAction_9_0(),
+ $current);
+ }
+)(this_FOR_11=RULE_FOR
+ {
+ newLeafNode(this_FOR_11, grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0());
+ }
+ lv_loop_12_0=ruleForBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "loop",
+ lv_loop_12_0,
+ "ForBody");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0());
+ }
+ lv_body_13_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_13_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0(),
+ $current);
+ }
+)(this_WHILE_15=RULE_WHILE
+ {
+ newLeafNode(this_WHILE_15, grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0());
+ }
+ lv_loop_16_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "loop",
+ lv_loop_16_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_WHEN_17=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_17, grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0());
+ }
+ lv_when_18_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_18_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0());
+ }
+ lv_body_19_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_19_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0(),
+ $current);
+ }
+)(this_UNTIL_21=RULE_UNTIL
+ {
+ newLeafNode(this_UNTIL_21, grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0());
+ }
+ lv_loop_22_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "loop",
+ lv_loop_22_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_WHEN_23=RULE_WHEN
+ {
+ newLeafNode(this_WHEN_23, grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0());
+ }
+ lv_when_24_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "when",
+ lv_when_24_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0());
+ }
+ lv_body_25_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_25_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0(),
+ $current);
+ }
+)(this_LOOP_27=RULE_LOOP
+ {
+ newLeafNode(this_LOOP_27, grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0());
+ }
+ lv_body_28_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_28_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0(),
+ $current);
+ }
+)(this_TRY_30=RULE_TRY
+ {
+ newLeafNode(this_TRY_30, grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0());
+ }
+ lv_body_31_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_31_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((this_CATCH_32=RULE_CATCH
+ {
+ newLeafNode(this_CATCH_32, grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0());
+ }
+ lv_exception_33_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "exception",
+ lv_exception_33_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0());
+ }
+ lv_catchBlock_34_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "catchBlock",
+ lv_catchBlock_34_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_FINALLY_35=RULE_FINALLY
+ {
+ newLeafNode(this_FINALLY_35, grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0());
+ }
+ lv_finallyBlock_36_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "finallyBlock",
+ lv_finallyBlock_36_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+ |(this_FINALLY_37=RULE_FINALLY
+ {
+ newLeafNode(this_FINALLY_37, grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0());
+ }
+ lv_finallyBlock_38_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "finallyBlock",
+ lv_finallyBlock_38_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))?))
+ |((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0(),
+ $current);
+ }
+)(this_SWITCH_40=RULE_SWITCH
+ {
+ newLeafNode(this_SWITCH_40, grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0());
+ }
+ lv_exp_41_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "exp",
+ lv_exp_41_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?this_INDENT_42=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_42, grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0());
+ }
+ lv_cases_43_0=ruleCase {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ add(
+ $current,
+ "cases",
+ lv_cases_43_0,
+ "Case");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*(this_ELSE_44=RULE_ELSE
+ {
+ newLeafNode(this_ELSE_44, grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0());
+ }
+ lv_elseBlock_45_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ $current,
+ "elseBlock",
+ lv_elseBlock_45_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?this_OUTDENT_46=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_46, grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5());
+ }
+))
+ |
+ {
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15());
+ }
+ this_IdRef_47=ruleIdRef
+ {
+ $current = $this_IdRef_47.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleBlock
+entryRuleBlock returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBlockRule()); }
+ iv_ruleBlock=ruleBlock
+ { $current=$iv_ruleBlock.current; }
+ EOF
+;
+
+// Rule Block
+ruleBlock returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getBlockAccess().getBlockAction_0(),
+ $current);
+ }
+)this_INDENT_1=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_1, grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1());
+ }
+(
+ {
+ newCompositeNode(grammarAccess.getBlockAccess().getBodyParserRuleCall_2());
+ }
+ this_Body_2=ruleBody
+ {
+ $current = $this_Body_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)?this_OUTDENT_3=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_3, grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleCase
+entryRuleCase returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCaseRule()); }
+ iv_ruleCase=ruleCase
+ { $current=$iv_ruleCase.current; }
+ EOF
+;
+
+// Rule Case
+ruleCase returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(this_LEADING_WHEN_0=RULE_LEADING_WHEN
+ {
+ newLeafNode(this_LEADING_WHEN_0, grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0());
+ }
+ lv_whens_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ add(
+ $current,
+ "whens",
+ lv_whens_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_2=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_2, grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0());
+ }
+ lv_whens_3_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ add(
+ $current,
+ "whens",
+ lv_whens_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(
+(
+ {
+ newCompositeNode(grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0());
+ }
+ lv_then_4_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ set(
+ $current,
+ "then",
+ lv_then_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_TERMINATOR_5=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_5, grammarAccess.getCaseAccess().getTERMINATORTerminalRuleCall_4());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleIfExp
+entryRuleIfExp returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIfExpRule()); }
+ iv_ruleIfExp=ruleIfExp
+ { $current=$iv_ruleIfExp.current; }
+ EOF
+;
+
+// Rule IfExp
+ruleIfExp returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0());
+ }
+ lv_blocks_0_0=ruleCondBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ add(
+ $current,
+ "blocks",
+ lv_blocks_0_0,
+ "CondBlock");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_ELSE_1=RULE_ELSE
+ {
+ newLeafNode(this_ELSE_1, grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0());
+ }
+ lv_blocks_2_0=ruleCondBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ add(
+ $current,
+ "blocks",
+ lv_blocks_2_0,
+ "CondBlock");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(this_ELSE_3=RULE_ELSE
+ {
+ newLeafNode(this_ELSE_3, grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0());
+ }
+ lv_defaultBlock_4_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ set(
+ $current,
+ "defaultBlock",
+ lv_defaultBlock_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleCondBlock
+entryRuleCondBlock returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getCondBlockRule()); }
+ iv_ruleCondBlock=ruleCondBlock
+ { $current=$iv_ruleCondBlock.current; }
+ EOF
+;
+
+// Rule CondBlock
+ruleCondBlock returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_operator_0_0=RULE_IF
+ {
+ newLeafNode(lv_operator_0_0, grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getCondBlockRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "operator",
+ lv_operator_0_0,
+ "IF");
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0());
+ }
+ lv_condition_1_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCondBlockRule());
+ }
+ set(
+ $current,
+ "condition",
+ lv_condition_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0());
+ }
+ lv_action_2_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getCondBlockRule());
+ }
+ set(
+ $current,
+ "action",
+ lv_action_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleIdRef
+entryRuleIdRef returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIdRefRule()); }
+ iv_ruleIdRef=ruleIdRef
+ { $current=$iv_ruleIdRef.current; }
+ EOF
+;
+
+// Rule IdRef
+ruleIdRef returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIdRefRule());
+ }
+ }
+ otherlv_0=RULE_IDENTIFIER
+ {
+ newLeafNode(otherlv_0, grammarAccess.getIdRefAccess().getValIdCrossReference_0());
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleId
+entryRuleId returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getIdRule()); }
+ iv_ruleId=ruleId
+ { $current=$iv_ruleId.current; }
+ EOF
+;
+
+// Rule Id
+ruleId returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ lv_name_0_0=RULE_IDENTIFIER
+ {
+ newLeafNode(lv_name_0_0, grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getIdRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "name",
+ lv_name_0_0,
+ "IDENTIFIER");
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleProperty
+entryRuleProperty returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getPropertyRule()); }
+ iv_ruleProperty=ruleProperty
+ { $current=$iv_ruleProperty.current; }
+ EOF
+;
+
+// Rule Property
+ruleProperty returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((( ruleIdRef(
+(
+(
+RULE_DOT
+
+ | RULE_DOUBLE_COLON
+
+ | RULE_QUESTION_DOT
+
+)
+
+)
+)))=>(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0());
+ }
+ this_IdRef_0=ruleIdRef
+ {
+ $current = $this_IdRef_0.current;
+ afterParserOrEnumRuleCall();
+ }
+(
+(
+(
+ lv_accessor_1_1=RULE_DOT
+ {
+ newLeafNode(lv_accessor_1_1, grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_1_1,
+ "DOT");
+ }
+
+ | lv_accessor_1_2=RULE_DOUBLE_COLON
+ {
+ newLeafNode(lv_accessor_1_2, grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_1_2,
+ "DOUBLE_COLON");
+ }
+
+ | lv_accessor_1_3=RULE_QUESTION_DOT
+ {
+ newLeafNode(lv_accessor_1_3, grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "accessor",
+ lv_accessor_1_3,
+ "QUESTION_DOT");
+ }
+
+)
+
+)
+)))(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0());
+ }
+ lv_prop_2_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ $current,
+ "prop",
+ lv_prop_2_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(((( ruleIdRef RULE_INDEX_START))=>(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0());
+ }
+ this_IdRef_3=ruleIdRef
+ {
+ $current = $this_IdRef_3.current;
+ afterParserOrEnumRuleCall();
+ }
+this_INDEX_START_4=RULE_INDEX_START
+ {
+ newLeafNode(this_INDEX_START_4, grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1());
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0());
+ }
+ lv_index_5_0=ruleIndex {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ $current,
+ "index",
+ lv_index_5_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_INDEX_END_6=RULE_INDEX_END
+ {
+ newLeafNode(this_INDEX_END_6, grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2());
+ }
+))
+;
+
+
+
+
+
+// Entry rule entryRuleVariable
+entryRuleVariable returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getVariableRule()); }
+ iv_ruleVariable=ruleVariable
+ { $current=$iv_ruleVariable.current; }
+ EOF
+;
+
+// Rule Variable
+ruleVariable returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getVariableAccess().getIdParserRuleCall_0());
+ }
+ this_Id_0=ruleId
+ {
+ $current = $this_Id_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |((this_AT_SIGIL_1=RULE_AT_SIGIL
+ {
+ newLeafNode(this_AT_SIGIL_1, grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0());
+ }
+
+ |(this_THIS_2=RULE_THIS
+ {
+ newLeafNode(this_THIS_2, grammarAccess.getVariableAccess().getTHISTerminalRuleCall_1_0_1_0());
+ }
+this_DOT_3=RULE_DOT
+ {
+ newLeafNode(this_DOT_3, grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_0_1_1());
+ }
+))
+ {
+ newCompositeNode(grammarAccess.getVariableAccess().getIdParserRuleCall_1_1());
+ }
+ this_Id_4=ruleId
+ {
+ $current = $this_Id_4.current;
+ afterParserOrEnumRuleCall();
+ }
+(this_DOT_5=RULE_DOT
+ {
+ newLeafNode(this_DOT_5, grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0());
+ }
+ lv_props_6_0=ruleId {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getVariableRule());
+ }
+ add(
+ $current,
+ "props",
+ lv_props_6_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+ |
+ {
+ newCompositeNode(grammarAccess.getVariableAccess().getPropertyParserRuleCall_2());
+ }
+ this_Property_7=ruleProperty
+ {
+ $current = $this_Property_7.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignableArray
+entryRuleAssignableArray returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignableArrayRule()); }
+ iv_ruleAssignableArray=ruleAssignableArray
+ { $current=$iv_ruleAssignableArray.current; }
+ EOF
+;
+
+// Rule AssignableArray
+ruleAssignableArray returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((( RULE_LBRACKET)=>this_LBRACKET_0=RULE_LBRACKET
+ {
+ newLeafNode(this_LBRACKET_0, grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1());
+ }
+ this_AssignableArgList_1=ruleAssignableArgList
+ {
+ $current = $this_AssignableArgList_1.current;
+ afterParserOrEnumRuleCall();
+ }
+this_RBRACKET_2=RULE_RBRACKET
+ {
+ newLeafNode(this_RBRACKET_2, grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignableArgList
+entryRuleAssignableArgList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignableArgListRule()); }
+ iv_ruleAssignableArgList=ruleAssignableArgList
+ { $current=$iv_ruleAssignableArgList.current; }
+ EOF
+;
+
+// Rule AssignableArgList
+ruleAssignableArgList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0());
+ }
+ lv_args_0_0=ruleAssignableArg {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignableArgListRule());
+ }
+ add(
+ $current,
+ "args",
+ lv_args_0_0,
+ "AssignableArg");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_1=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_1, grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0());
+ }
+ lv_args_2_0=ruleAssignableArg {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignableArgListRule());
+ }
+ add(
+ $current,
+ "args",
+ lv_args_2_0,
+ "AssignableArg");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignableArg
+entryRuleAssignableArg returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignableArgRule()); }
+ iv_ruleAssignableArg=ruleAssignableArg
+ { $current=$iv_ruleAssignableArg.current; }
+ EOF
+;
+
+// Rule AssignableArg
+ruleAssignableArg returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0());
+ }
+ lv_arg_0_0=ruleAssignable {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAssignableArgRule());
+ }
+ set(
+ $current,
+ "arg",
+ lv_arg_0_0,
+ "Assignable");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ lv_splat_1_0=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_splat_1_0, grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAssignableArgRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "splat",
+ true,
+ "ELLIPSIS");
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleAssignable
+entryRuleAssignable returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAssignableRule()); }
+ iv_ruleAssignable=ruleAssignable
+ { $current=$iv_ruleAssignable.current; }
+ EOF
+;
+
+// Rule Assignable
+ruleAssignable returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getAssignableAccess().getVariableParserRuleCall_0());
+ }
+ this_Variable_0=ruleVariable
+ {
+ $current = $this_Variable_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |(( RULE_LCURLY)=>
+ {
+ newCompositeNode(grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1());
+ }
+ this_Dictionary_1=ruleDictionary
+ {
+ $current = $this_Dictionary_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(( RULE_LBRACKET)=>
+ {
+ newCompositeNode(grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2());
+ }
+ this_AssignableArray_2=ruleAssignableArray
+ {
+ $current = $this_AssignableArray_2.current;
+ afterParserOrEnumRuleCall();
+ }
+))
+;
+
+
+
+
+
+// Entry rule entryRuleArg
+entryRuleArg returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getArgRule()); }
+ iv_ruleArg=ruleArg
+ { $current=$iv_ruleArg.current; }
+ EOF
+;
+
+// Rule Arg
+ruleArg returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0());
+ }
+ lv_exp_0_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgRule());
+ }
+ set(
+ $current,
+ "exp",
+ lv_exp_0_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(
+(
+ lv_splat_1_0=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_splat_1_0, grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getArgRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "splat",
+ true,
+ "ELLIPSIS");
+ }
+
+)
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleArgLine
+entryRuleArgLine returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getArgLineRule()); }
+ iv_ruleArgLine=ruleArgLine
+ { $current=$iv_ruleArgLine.current; }
+ EOF
+;
+
+// Rule ArgLine
+ruleArgLine returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0());
+ }
+ lv_head_0_0=ruleArg {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgLineRule());
+ }
+ set(
+ $current,
+ "head",
+ lv_head_0_0,
+ "Arg");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_1=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_1, grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0());
+ }
+ lv_tail_2_0=ruleArg {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgLineRule());
+ }
+ add(
+ $current,
+ "tail",
+ lv_tail_2_0,
+ "Arg");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(this_COMMA_3=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_3, grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleExplicitArgList
+entryRuleExplicitArgList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExplicitArgListRule()); }
+ iv_ruleExplicitArgList=ruleExplicitArgList
+ { $current=$iv_ruleExplicitArgList.current; }
+ EOF
+;
+
+// Rule ExplicitArgList
+ruleExplicitArgList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0());
+ }
+ lv_lines_0_0=ruleArgLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_0_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((this_TERMINATOR_1=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0());
+ }
+ lv_lines_2_0=ruleArgLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_2_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(this_INDENT_3=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_3, grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0());
+ }
+ lv_lines_4_0=ruleArgLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_4_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_5=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_5, grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleArgList
+entryRuleArgList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getArgListRule()); }
+ iv_ruleArgList=ruleArgList
+ { $current=$iv_ruleArgList.current; }
+ EOF
+;
+
+// Rule ArgList
+ruleArgList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getArgListAccess().getArgListAction_0(),
+ $current);
+ }
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0());
+ }
+ lv_dummy_1_0=ruleExplicitArgList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgListRule());
+ }
+ set(
+ $current,
+ "dummy",
+ lv_dummy_1_0,
+ "ExplicitArgList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(this_INDENT_2=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_2, grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0());
+ }
+ lv_dummy_3_0=ruleExplicitArgList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getArgListRule());
+ }
+ set(
+ $current,
+ "dummy",
+ lv_dummy_3_0,
+ "ExplicitArgList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_4=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_4, grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleArray
+entryRuleArray returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getArrayRule()); }
+ iv_ruleArray=ruleArray
+ { $current=$iv_ruleArray.current; }
+ EOF
+;
+
+// Rule Array
+ruleArray returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((( RULE_LBRACKET)=>this_LBRACKET_0=RULE_LBRACKET
+ {
+ newLeafNode(this_LBRACKET_0, grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getArrayAccess().getArgListParserRuleCall_1());
+ }
+ this_ArgList_1=ruleArgList
+ {
+ $current = $this_ArgList_1.current;
+ afterParserOrEnumRuleCall();
+ }
+this_RBRACKET_2=RULE_RBRACKET
+ {
+ newLeafNode(this_RBRACKET_2, grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleDictionary
+entryRuleDictionary returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictionaryRule()); }
+ iv_ruleDictionary=ruleDictionary
+ { $current=$iv_ruleDictionary.current; }
+ EOF
+;
+
+// Rule Dictionary
+ruleDictionary returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((( RULE_LCURLY)=>this_LCURLY_0=RULE_LCURLY
+ {
+ newLeafNode(this_LCURLY_0, grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0());
+ }
+)
+ {
+ newCompositeNode(grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1());
+ }
+ this_DictItems_1=ruleDictItems
+ {
+ $current = $this_DictItems_1.current;
+ afterParserOrEnumRuleCall();
+ }
+this_RCURLY_2=RULE_RCURLY
+ {
+ newLeafNode(this_RCURLY_2, grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleDictItems
+entryRuleDictItems returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictItemsRule()); }
+ iv_ruleDictItems=ruleDictItems
+ { $current=$iv_ruleDictItems.current; }
+ EOF
+;
+
+// Rule DictItems
+ruleDictItems returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getDictItemsAccess().getDictItemsAction_0(),
+ $current);
+ }
+)((
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0());
+ }
+ lv_dummy_1_0=ruleExplicitDictItems {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemsRule());
+ }
+ set(
+ $current,
+ "dummy",
+ lv_dummy_1_0,
+ "ExplicitDictItems");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(this_INDENT_2=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_2, grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0());
+ }
+ lv_dummy_3_0=ruleExplicitDictItems {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemsRule());
+ }
+ set(
+ $current,
+ "dummy",
+ lv_dummy_3_0,
+ "ExplicitDictItems");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_4=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_4, grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+))?)
+;
+
+
+
+
+
+// Entry rule entryRuleExplicitDictItems
+entryRuleExplicitDictItems returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExplicitDictItemsRule()); }
+ iv_ruleExplicitDictItems=ruleExplicitDictItems
+ { $current=$iv_ruleExplicitDictItems.current; }
+ EOF
+;
+
+// Rule ExplicitDictItems
+ruleExplicitDictItems returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0());
+ }
+ lv_lines_0_0=ruleDictLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_0_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)((this_TERMINATOR_1=RULE_TERMINATOR
+ {
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0());
+ }
+ lv_lines_2_0=ruleDictLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_2_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+ |(this_INDENT_3=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_3, grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0());
+ }
+ lv_lines_4_0=ruleDictLine {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ $current,
+ "lines",
+ lv_lines_4_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_5=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_5, grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+ }
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleDictLine
+entryRuleDictLine returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictLineRule()); }
+ iv_ruleDictLine=ruleDictLine
+ { $current=$iv_ruleDictLine.current; }
+ EOF
+;
+
+// Rule DictLine
+ruleDictLine returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0());
+ }
+ lv_head_0_0=ruleDictItem {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictLineRule());
+ }
+ set(
+ $current,
+ "head",
+ lv_head_0_0,
+ "DictItem");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_1=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_1, grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0());
+ }
+ lv_tail_2_0=ruleDictItem {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictLineRule());
+ }
+ add(
+ $current,
+ "tail",
+ lv_tail_2_0,
+ "DictItem");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*(this_COMMA_3=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_3, grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleDictItem
+entryRuleDictItem returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictItemRule()); }
+ iv_ruleDictItem=ruleDictItem
+ { $current=$iv_ruleDictItem.current; }
+ EOF
+;
+
+// Rule DictItem
+ruleDictItem returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getDictItemAccess().getDictItemAction_0(),
+ $current);
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0());
+ }
+ lv_key_1_0=ruleDictKey {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ $current,
+ "key",
+ lv_key_1_0,
+ "DictKey");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COLON_2=RULE_COLON
+ {
+ newLeafNode(this_COLON_2, grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0());
+ }
+ lv_value_3_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(this_INDENT_4=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_4, grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0());
+ }
+ lv_value_5_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ $current,
+ "value",
+ lv_value_5_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_6=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_6, grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2());
+ }
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleDictKey
+entryRuleDictKey returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDictKeyRule()); }
+ iv_ruleDictKey=ruleDictKey
+ { $current=$iv_ruleDictKey.current; }
+ EOF
+;
+
+// Rule DictKey
+ruleDictKey returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0());
+ }
+ this_Literal_0=ruleLiteral
+ {
+ $current = $this_Literal_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getDictKeyAccess().getIdParserRuleCall_1());
+ }
+ this_Id_1=ruleId
+ {
+ $current = $this_Id_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleLambda
+entryRuleLambda returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLambdaRule()); }
+ iv_ruleLambda=ruleLambda
+ { $current=$iv_ruleLambda.current; }
+ EOF
+;
+
+// Rule Lambda
+ruleLambda returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((this_PARAM_START_0=RULE_PARAM_START
+ {
+ newLeafNode(this_PARAM_START_0, grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0());
+ }
+ lv_params_1_0=ruleParam {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ add(
+ $current,
+ "params",
+ lv_params_1_0,
+ "Param");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)(this_COMMA_2=RULE_COMMA
+ {
+ newLeafNode(this_COMMA_2, grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0());
+ }
+ lv_params_3_0=ruleParam {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ add(
+ $current,
+ "params",
+ lv_params_3_0,
+ "Param");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)?this_PARAM_END_4=RULE_PARAM_END
+ {
+ newLeafNode(this_PARAM_END_4, grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2());
+ }
+)?(this_FUNC_ARROW_5=RULE_FUNC_ARROW
+ {
+ newLeafNode(this_FUNC_ARROW_5, grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0());
+ }
+
+ |this_BOUND_FUNC_ARROW_6=RULE_BOUND_FUNC_ARROW
+ {
+ newLeafNode(this_BOUND_FUNC_ARROW_6, grammarAccess.getLambdaAccess().getBOUND_FUNC_ARROWTerminalRuleCall_1_1());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0());
+ }
+ lv_body_7_0=ruleBlock {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ set(
+ $current,
+ "body",
+ lv_body_7_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleParam
+entryRuleParam returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getParamRule()); }
+ iv_ruleParam=ruleParam
+ { $current=$iv_ruleParam.current; }
+ EOF
+;
+
+// Rule Param
+ruleParam returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getIdParserRuleCall_0_0());
+ }
+ this_Id_0=ruleId
+ {
+ $current = $this_Id_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |(( RULE_LBRACKET)=>
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getArrayParserRuleCall_0_1());
+ }
+ this_Array_1=ruleArray
+ {
+ $current = $this_Array_1.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |(( RULE_LCURLY)=>
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2());
+ }
+ this_Dictionary_2=ruleDictionary
+ {
+ $current = $this_Dictionary_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+ |
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3());
+ }
+ this_ThisProperty_3=ruleThisProperty
+ {
+ $current = $this_ThisProperty_3.current;
+ afterParserOrEnumRuleCall();
+ }
+)((
+(
+ lv_splat_4_0=RULE_ELLIPSIS
+ {
+ newLeafNode(lv_splat_4_0, grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getParamRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "splat",
+ true,
+ "ELLIPSIS");
+ }
+
+)
+)
+ |(this_EQUAL_5=RULE_EQUAL
+ {
+ newLeafNode(this_EQUAL_5, grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0());
+ }
+ lv_defaultValue_6_0=ruleExpression {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getParamRule());
+ }
+ set(
+ $current,
+ "defaultValue",
+ lv_defaultValue_6_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)))?)
+;
+
+
+
+
+
+// Entry rule entryRuleNumberLiteral
+entryRuleNumberLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getNumberLiteralRule()); }
+ iv_ruleNumberLiteral=ruleNumberLiteral
+ { $current=$iv_ruleNumberLiteral.current; }
+ EOF
+;
+
+// Rule NumberLiteral
+ruleNumberLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0(),
+ $current);
+ }
+)this_NUMBER_1=RULE_NUMBER
+ {
+ newLeafNode(this_NUMBER_1, grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleStringLiteral
+entryRuleStringLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStringLiteralRule()); }
+ iv_ruleStringLiteral=ruleStringLiteral
+ { $current=$iv_ruleStringLiteral.current; }
+ EOF
+;
+
+// Rule StringLiteral
+ruleStringLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getStringLiteralAccess().getStringLiteralAction_0(),
+ $current);
+ }
+)this_STRING_1=RULE_STRING
+ {
+ newLeafNode(this_STRING_1, grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleBoolLiteral
+entryRuleBoolLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBoolLiteralRule()); }
+ iv_ruleBoolLiteral=ruleBoolLiteral
+ { $current=$iv_ruleBoolLiteral.current; }
+ EOF
+;
+
+// Rule BoolLiteral
+ruleBoolLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0(),
+ $current);
+ }
+)this_BOOL_1=RULE_BOOL
+ {
+ newLeafNode(this_BOOL_1, grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleJSLiteral
+entryRuleJSLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getJSLiteralRule()); }
+ iv_ruleJSLiteral=ruleJSLiteral
+ { $current=$iv_ruleJSLiteral.current; }
+ EOF
+;
+
+// Rule JSLiteral
+ruleJSLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getJSLiteralAccess().getJSLiteralAction_0(),
+ $current);
+ }
+)this_JS_1=RULE_JS
+ {
+ newLeafNode(this_JS_1, grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleRegexLiteral
+entryRuleRegexLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRegexLiteralRule()); }
+ iv_ruleRegexLiteral=ruleRegexLiteral
+ { $current=$iv_ruleRegexLiteral.current; }
+ EOF
+;
+
+// Rule RegexLiteral
+ruleRegexLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0(),
+ $current);
+ }
+)this_REGEX_1=RULE_REGEX
+ {
+ newLeafNode(this_REGEX_1, grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleLiteral
+entryRuleLiteral returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getLiteralRule()); }
+ iv_ruleLiteral=ruleLiteral
+ { $current=$iv_ruleLiteral.current; }
+ EOF
+;
+
+// Rule Literal
+ruleLiteral returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0());
+ }
+ this_NumberLiteral_0=ruleNumberLiteral
+ {
+ $current = $this_NumberLiteral_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1());
+ }
+ this_StringLiteral_1=ruleStringLiteral
+ {
+ $current = $this_StringLiteral_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2());
+ }
+ this_BoolLiteral_2=ruleBoolLiteral
+ {
+ $current = $this_BoolLiteral_2.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3());
+ }
+ this_JSLiteral_3=ruleJSLiteral
+ {
+ $current = $this_JSLiteral_3.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4());
+ }
+ this_RegexLiteral_4=ruleRegexLiteral
+ {
+ $current = $this_RegexLiteral_4.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleParenthetical
+entryRuleParenthetical returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getParentheticalRule()); }
+ iv_ruleParenthetical=ruleParenthetical
+ { $current=$iv_ruleParenthetical.current; }
+ EOF
+;
+
+// Rule Parenthetical
+ruleParenthetical returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((((( RULE_LPAREN RULE_INDENT))=>(this_LPAREN_0=RULE_LPAREN
+ {
+ newLeafNode(this_LPAREN_0, grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0());
+ }
+this_INDENT_1=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_1, grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1());
+ }
+))(
+(
+ {
+ newCompositeNode(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0());
+ }
+ lv_content_2_0=ruleBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getParentheticalRule());
+ }
+ set(
+ $current,
+ "content",
+ lv_content_2_0,
+ "Body");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_OUTDENT_3=RULE_OUTDENT
+ {
+ newLeafNode(this_OUTDENT_3, grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2());
+ }
+this_RPAREN_4=RULE_RPAREN
+ {
+ newLeafNode(this_RPAREN_4, grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3());
+ }
+)
+ |((( RULE_LPAREN)=>this_LPAREN_5=RULE_LPAREN
+ {
+ newLeafNode(this_LPAREN_5, grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0());
+ }
+)(
+(
+ {
+ newCompositeNode(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0());
+ }
+ lv_content_6_0=ruleBody {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getParentheticalRule());
+ }
+ set(
+ $current,
+ "content",
+ lv_content_6_0,
+ "Body");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)this_RPAREN_7=RULE_RPAREN
+ {
+ newLeafNode(this_RPAREN_7, grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2());
+ }
+))
+;
+
+
+
+
+
+RULE_TASK : 'task';
+
+RULE_ELLIPSIS : '...';
+
+RULE_DOT_DOT : '..';
+
+RULE_DOUBLE_COLON : '::';
+
+RULE_SHIFT : ('<<'|'>>');
+
+RULE_BOUND_FUNC_ARROW : '=>';
+
+RULE_FUNC_ARROW : '->';
+
+RULE_COMPARE : ('<'|'=='|'>'|'<='|'>='|'!=');
+
+RULE_COMPOUND_ASSIGN : ('+='|'-=');
+
+RULE_PLUS_PLUS : '++';
+
+RULE_MINUS_MINUS : '--';
+
+RULE_PARAM_END : '**)';
+
+RULE_PARAM_START : '(**';
+
+RULE_AT_SIGIL : '@';
+
+RULE_BOOL : ('true'|'false'|'undefined'|'null'|'on'|'no'|'yes'|'off');
+
+RULE_BY : 'by';
+
+RULE_CALL_END : '*)';
+
+RULE_CALL_START : '(*';
+
+RULE_CATCH : 'catch';
+
+RULE_CLASS : 'class';
+
+RULE_COLON : ':';
+
+RULE_COLON_SLASH : 'dummy COLON_SLASH';
+
+RULE_COMMA : ',';
+
+RULE_DOT : '.';
+
+RULE_ELSE : 'else';
+
+RULE_EQUAL : '=';
+
+RULE_EXTENDS : 'extends';
+
+RULE_FINALLY : 'finally';
+
+RULE_FOR : 'for';
+
+RULE_FORIN : 'in';
+
+RULE_FOROF : 'of';
+
+RULE_FUNC_EXIST : 'dummy FUNC_EXIST';
+
+RULE_HERECOMMENT : 'dummy HERECOMMENT';
+
+RULE_IF : ('if'|'unless');
+
+RULE_INDENT : '{*';
+
+RULE_INDEX_END : '*]';
+
+RULE_INDEX_PROTO : 'dummy INDEX_PROTO';
+
+RULE_INDEX_SOAK : 'dummy INDEX_SOAK';
+
+RULE_INDEX_START : '[*';
+
+RULE_JS : 'dummy JS';
+
+RULE_LBRACKET : '[';
+
+RULE_LCURLY : 'dummy LCURLY';
+
+RULE_LEADING_WHEN : 'dummy LEADING_WHEN';
+
+RULE_LOGIC : ('&&'|'||');
+
+RULE_LOOP : 'loop';
+
+RULE_LPAREN : '(';
+
+RULE_MATH : ('*'|'/');
+
+RULE_MINUS : '-';
+
+RULE_NEW : 'new';
+
+RULE_NUMBER : ('0'..'9')+;
+
+RULE_OUTDENT : '*}';
+
+RULE_OWN : 'own';
+
+RULE_PLUS : '+';
+
+RULE_POST_IF : 'dummy POST_IF';
+
+RULE_QUESTION : '?';
+
+RULE_QUESTION_DOT : '?.';
+
+RULE_RBRACKET : ']';
+
+RULE_RCURLY : 'dummy RCURLY';
+
+RULE_REGEX : '///' ( options {greedy=false;} : . )*'///';
+
+RULE_RELATION : ('in'|'of'|'instanceof');
+
+RULE_RETURN : 'return';
+
+RULE_RPAREN : ')';
+
+RULE_STATEMENT : ('break'|'continue'|'debugger');
+
+RULE_STRING : ('\'\'\'' ( options {greedy=false;} : . )*'\'\'\''|'\'' (~('\'') ('\\' ('b'|'t'|'n'|'f'|'r'|'u'|'"'|'\''|'\\')|~(('\\'|'\'')))*)? '\''|'"""' ( options {greedy=false;} : . )*'"""'|'"' (~('"') ('\\' ('b'|'t'|'n'|'f'|'r'|'u'|'"'|'\''|'\\')|~(('\\'|'"')))*)? '"');
+
+RULE_SUPER : 'super';
+
+RULE_SWITCH : 'switch';
+
+RULE_TERMINATOR : '\n'+;
+
+RULE_THEN : 'then';
+
+RULE_THIS : 'this';
+
+RULE_THROW : 'throw';
+
+RULE_TRY : 'try';
+
+RULE_UNARY : ('!'|'~');
+
+RULE_UNTIL : 'until';
+
+RULE_WHEN : 'when';
+
+RULE_WHILE : 'while';
+
+RULE_LOGIC_WORD : ('and'|'or');
+
+RULE_COMPARE_WORD : ('isnt'|'is');
+
+RULE_UNARY_WORD : ('new'|'do'|'not');
+
+RULE_ML_COMMENT : '###' ~('#') ( options {greedy=false;} : . )*'###';
+
+RULE_SL_COMMENT : '#' ~(('\n'|'\r'))* ('\r'? '\n')?;
+
+RULE_WS : (' '|'\t')+;
+
+RULE_IDENTIFIER : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
+
+
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.tokens b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.tokens
new file mode 100644
index 0000000..af4a910
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.tokens
@@ -0,0 +1,84 @@
+RULE_BOUND_FUNC_ARROW=68
+RULE_SWITCH=60
+RULE_THROW=18
+RULE_PARAM_START=7
+RULE_TERMINATOR=11
+RULE_CALL_END=10
+RULE_RETURN=16
+RULE_FOR=21
+RULE_BOOL=70
+RULE_LBRACKET=29
+RULE_DOUBLE_COLON=52
+RULE_MINUS_MINUS=45
+RULE_COMPARE_WORD=81
+RULE_OUTDENT=35
+RULE_RELATION=38
+RULE_REGEX=72
+RULE_CLASS=19
+RULE_WHILE=22
+RULE_COLON_SLASH=75
+RULE_FUNC_EXIST=48
+RULE_DOT=50
+RULE_POST_IF=17
+RULE_PLUS_PLUS=44
+RULE_OWN=25
+RULE_NUMBER=69
+RULE_LOOP=56
+RULE_LPAREN=73
+RULE_FUNC_ARROW=9
+RULE_AT_SIGIL=49
+RULE_EXTENDS=20
+RULE_SHIFT=39
+RULE_INDEX_END=54
+RULE_COMPARE=37
+RULE_QUESTION_DOT=51
+RULE_RBRACKET=32
+RULE_COMPOUND_ASSIGN=33
+RULE_SUPER=47
+RULE_THEN=79
+RULE_UNARY_WORD=82
+RULE_LEADING_WHEN=62
+RULE_TASK=4
+RULE_DOT_DOT=30
+RULE_STATEMENT=12
+RULE_PLUS=40
+RULE_BY=28
+RULE_INDEX_SOAK=77
+RULE_CATCH=58
+RULE_CALL_START=5
+RULE_INDEX_PROTO=76
+RULE_IDENTIFIER=64
+RULE_COMMA=6
+RULE_TRY=57
+RULE_JS=71
+RULE_EQUAL=14
+RULE_INDENT=34
+RULE_HERECOMMENT=13
+RULE_FORIN=27
+RULE_ELLIPSIS=31
+RULE_SL_COMMENT=84
+RULE_PARAM_END=8
+T__86=86
+RULE_ML_COMMENT=83
+RULE_WHEN=23
+RULE_INDEX_START=53
+RULE_COLON=67
+RULE_MINUS=41
+RULE_STRING=15
+RULE_NEW=78
+RULE_LOGIC_WORD=80
+RULE_LOGIC=36
+RULE_RPAREN=74
+RULE_WS=85
+RULE_FOROF=26
+RULE_IF=63
+RULE_THIS=55
+RULE_UNARY=43
+RULE_RCURLY=66
+RULE_ELSE=61
+RULE_FINALLY=59
+RULE_MATH=42
+RULE_LCURLY=65
+RULE_QUESTION=46
+RULE_UNTIL=24
+'require'=86
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefileLexer.java b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefileLexer.java
new file mode 100644
index 0000000..06c4ca6
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefileLexer.java
@@ -0,0 +1,4260 @@
+package csep.example.cake.parser.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.parser.antlr.Lexer;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalCakefileLexer extends Lexer {
+ public static final int RULE_BOUND_FUNC_ARROW=68;
+ public static final int RULE_SWITCH=60;
+ public static final int RULE_THROW=18;
+ public static final int RULE_PARAM_START=7;
+ public static final int RULE_TERMINATOR=11;
+ public static final int RULE_CALL_END=10;
+ public static final int RULE_RETURN=16;
+ public static final int RULE_FOR=21;
+ public static final int RULE_BOOL=70;
+ public static final int RULE_LBRACKET=29;
+ public static final int RULE_DOUBLE_COLON=52;
+ public static final int RULE_MINUS_MINUS=45;
+ public static final int RULE_COMPARE_WORD=81;
+ public static final int RULE_OUTDENT=35;
+ public static final int EOF=-1;
+ public static final int RULE_RELATION=38;
+ public static final int RULE_REGEX=72;
+ public static final int RULE_CLASS=19;
+ public static final int RULE_WHILE=22;
+ public static final int RULE_COLON_SLASH=75;
+ public static final int RULE_FUNC_EXIST=48;
+ public static final int RULE_DOT=50;
+ public static final int RULE_POST_IF=17;
+ public static final int RULE_PLUS_PLUS=44;
+ public static final int RULE_OWN=25;
+ public static final int RULE_NUMBER=69;
+ public static final int RULE_LOOP=56;
+ public static final int RULE_LPAREN=73;
+ public static final int RULE_FUNC_ARROW=9;
+ public static final int RULE_AT_SIGIL=49;
+ public static final int RULE_EXTENDS=20;
+ public static final int RULE_SHIFT=39;
+ public static final int RULE_INDEX_END=54;
+ public static final int RULE_COMPARE=37;
+ public static final int RULE_QUESTION_DOT=51;
+ public static final int RULE_RBRACKET=32;
+ public static final int RULE_COMPOUND_ASSIGN=33;
+ public static final int RULE_SUPER=47;
+ public static final int RULE_THEN=79;
+ public static final int RULE_UNARY_WORD=82;
+ public static final int RULE_LEADING_WHEN=62;
+ public static final int RULE_TASK=4;
+ public static final int RULE_DOT_DOT=30;
+ public static final int RULE_STATEMENT=12;
+ public static final int RULE_PLUS=40;
+ public static final int RULE_BY=28;
+ public static final int RULE_CATCH=58;
+ public static final int RULE_INDEX_SOAK=77;
+ public static final int RULE_CALL_START=5;
+ public static final int RULE_COMMA=6;
+ public static final int RULE_IDENTIFIER=64;
+ public static final int RULE_INDEX_PROTO=76;
+ public static final int RULE_TRY=57;
+ public static final int RULE_INDENT=34;
+ public static final int RULE_EQUAL=14;
+ public static final int RULE_JS=71;
+ public static final int RULE_HERECOMMENT=13;
+ public static final int RULE_ELLIPSIS=31;
+ public static final int RULE_FORIN=27;
+ public static final int RULE_SL_COMMENT=84;
+ public static final int RULE_PARAM_END=8;
+ public static final int T__86=86;
+ public static final int RULE_WHEN=23;
+ public static final int RULE_ML_COMMENT=83;
+ public static final int RULE_INDEX_START=53;
+ public static final int RULE_MINUS=41;
+ public static final int RULE_COLON=67;
+ public static final int RULE_STRING=15;
+ public static final int RULE_NEW=78;
+ public static final int RULE_LOGIC_WORD=80;
+ public static final int RULE_LOGIC=36;
+ public static final int RULE_RPAREN=74;
+ public static final int RULE_WS=85;
+ public static final int RULE_FOROF=26;
+ public static final int RULE_UNARY=43;
+ public static final int RULE_THIS=55;
+ public static final int RULE_IF=63;
+ public static final int RULE_ELSE=61;
+ public static final int RULE_RCURLY=66;
+ public static final int RULE_MATH=42;
+ public static final int RULE_FINALLY=59;
+ public static final int RULE_UNTIL=24;
+ public static final int RULE_QUESTION=46;
+ public static final int RULE_LCURLY=65;
+
+ // delegates
+ // delegators
+
+ public InternalCakefileLexer() {;}
+ public InternalCakefileLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalCakefileLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g"; }
+
+ // $ANTLR start "T__86"
+ public final void mT__86() throws RecognitionException {
+ try {
+ int _type = T__86;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:11:7: ( 'require' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:11:9: 'require'
+ {
+ match("require");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__86"
+
+ // $ANTLR start "RULE_TASK"
+ public final void mRULE_TASK() throws RecognitionException {
+ try {
+ int _type = RULE_TASK;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5521:11: ( 'task' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5521:13: 'task'
+ {
+ match("task");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_TASK"
+
+ // $ANTLR start "RULE_ELLIPSIS"
+ public final void mRULE_ELLIPSIS() throws RecognitionException {
+ try {
+ int _type = RULE_ELLIPSIS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5523:15: ( '...' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5523:17: '...'
+ {
+ match("...");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ELLIPSIS"
+
+ // $ANTLR start "RULE_DOT_DOT"
+ public final void mRULE_DOT_DOT() throws RecognitionException {
+ try {
+ int _type = RULE_DOT_DOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5525:14: ( '..' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5525:16: '..'
+ {
+ match("..");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DOT_DOT"
+
+ // $ANTLR start "RULE_DOUBLE_COLON"
+ public final void mRULE_DOUBLE_COLON() throws RecognitionException {
+ try {
+ int _type = RULE_DOUBLE_COLON;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5527:19: ( '::' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5527:21: '::'
+ {
+ match("::");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DOUBLE_COLON"
+
+ // $ANTLR start "RULE_SHIFT"
+ public final void mRULE_SHIFT() throws RecognitionException {
+ try {
+ int _type = RULE_SHIFT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5529:12: ( ( '<<' | '>>' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5529:14: ( '<<' | '>>' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5529:14: ( '<<' | '>>' )
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0=='<') ) {
+ alt1=1;
+ }
+ else if ( (LA1_0=='>') ) {
+ alt1=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 1, 0, input);
+
+ throw nvae;
+ }
+ switch (alt1) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5529:15: '<<'
+ {
+ match("<<");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5529:20: '>>'
+ {
+ match(">>");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SHIFT"
+
+ // $ANTLR start "RULE_BOUND_FUNC_ARROW"
+ public final void mRULE_BOUND_FUNC_ARROW() throws RecognitionException {
+ try {
+ int _type = RULE_BOUND_FUNC_ARROW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5531:23: ( '=>' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5531:25: '=>'
+ {
+ match("=>");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_BOUND_FUNC_ARROW"
+
+ // $ANTLR start "RULE_FUNC_ARROW"
+ public final void mRULE_FUNC_ARROW() throws RecognitionException {
+ try {
+ int _type = RULE_FUNC_ARROW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5533:17: ( '->' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5533:19: '->'
+ {
+ match("->");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FUNC_ARROW"
+
+ // $ANTLR start "RULE_COMPARE"
+ public final void mRULE_COMPARE() throws RecognitionException {
+ try {
+ int _type = RULE_COMPARE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5535:14: ( ( '<' | '==' | '>' | '<=' | '>=' | '!=' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5535:16: ( '<' | '==' | '>' | '<=' | '>=' | '!=' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5535:16: ( '<' | '==' | '>' | '<=' | '>=' | '!=' )
+ int alt2=6;
+ switch ( input.LA(1) ) {
+ case '<':
+ {
+ int LA2_1 = input.LA(2);
+
+ if ( (LA2_1=='=') ) {
+ alt2=4;
+ }
+ else {
+ alt2=1;}
+ }
+ break;
+ case '=':
+ {
+ alt2=2;
+ }
+ break;
+ case '>':
+ {
+ int LA2_3 = input.LA(2);
+
+ if ( (LA2_3=='=') ) {
+ alt2=5;
+ }
+ else {
+ alt2=3;}
+ }
+ break;
+ case '!':
+ {
+ alt2=6;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 2, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt2) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5535:17: '<'
+ {
+ match('<');
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5535:21: '=='
+ {
+ match("==");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5535:26: '>'
+ {
+ match('>');
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5535:30: '<='
+ {
+ match("<=");
+
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5535:35: '>='
+ {
+ match(">=");
+
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5535:40: '!='
+ {
+ match("!=");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMPARE"
+
+ // $ANTLR start "RULE_COMPOUND_ASSIGN"
+ public final void mRULE_COMPOUND_ASSIGN() throws RecognitionException {
+ try {
+ int _type = RULE_COMPOUND_ASSIGN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5537:22: ( ( '+=' | '-=' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5537:24: ( '+=' | '-=' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5537:24: ( '+=' | '-=' )
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0=='+') ) {
+ alt3=1;
+ }
+ else if ( (LA3_0=='-') ) {
+ alt3=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 3, 0, input);
+
+ throw nvae;
+ }
+ switch (alt3) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5537:25: '+='
+ {
+ match("+=");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5537:30: '-='
+ {
+ match("-=");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMPOUND_ASSIGN"
+
+ // $ANTLR start "RULE_PLUS_PLUS"
+ public final void mRULE_PLUS_PLUS() throws RecognitionException {
+ try {
+ int _type = RULE_PLUS_PLUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5539:16: ( '++' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5539:18: '++'
+ {
+ match("++");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PLUS_PLUS"
+
+ // $ANTLR start "RULE_MINUS_MINUS"
+ public final void mRULE_MINUS_MINUS() throws RecognitionException {
+ try {
+ int _type = RULE_MINUS_MINUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5541:18: ( '--' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5541:20: '--'
+ {
+ match("--");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_MINUS_MINUS"
+
+ // $ANTLR start "RULE_PARAM_END"
+ public final void mRULE_PARAM_END() throws RecognitionException {
+ try {
+ int _type = RULE_PARAM_END;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5543:16: ( '**)' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5543:18: '**)'
+ {
+ match("**)");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PARAM_END"
+
+ // $ANTLR start "RULE_PARAM_START"
+ public final void mRULE_PARAM_START() throws RecognitionException {
+ try {
+ int _type = RULE_PARAM_START;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5545:18: ( '(**' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5545:20: '(**'
+ {
+ match("(**");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PARAM_START"
+
+ // $ANTLR start "RULE_AT_SIGIL"
+ public final void mRULE_AT_SIGIL() throws RecognitionException {
+ try {
+ int _type = RULE_AT_SIGIL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5547:15: ( '@' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5547:17: '@'
+ {
+ match('@');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_AT_SIGIL"
+
+ // $ANTLR start "RULE_BOOL"
+ public final void mRULE_BOOL() throws RecognitionException {
+ try {
+ int _type = RULE_BOOL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:11: ( ( 'true' | 'false' | 'undefined' | 'null' | 'on' | 'no' | 'yes' | 'off' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:13: ( 'true' | 'false' | 'undefined' | 'null' | 'on' | 'no' | 'yes' | 'off' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:13: ( 'true' | 'false' | 'undefined' | 'null' | 'on' | 'no' | 'yes' | 'off' )
+ int alt4=8;
+ alt4 = dfa4.predict(input);
+ switch (alt4) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:14: 'true'
+ {
+ match("true");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:21: 'false'
+ {
+ match("false");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:29: 'undefined'
+ {
+ match("undefined");
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:41: 'null'
+ {
+ match("null");
+
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:48: 'on'
+ {
+ match("on");
+
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:53: 'no'
+ {
+ match("no");
+
+
+ }
+ break;
+ case 7 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:58: 'yes'
+ {
+ match("yes");
+
+
+ }
+ break;
+ case 8 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5549:64: 'off'
+ {
+ match("off");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_BOOL"
+
+ // $ANTLR start "RULE_BY"
+ public final void mRULE_BY() throws RecognitionException {
+ try {
+ int _type = RULE_BY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5551:9: ( 'by' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5551:11: 'by'
+ {
+ match("by");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_BY"
+
+ // $ANTLR start "RULE_CALL_END"
+ public final void mRULE_CALL_END() throws RecognitionException {
+ try {
+ int _type = RULE_CALL_END;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5553:15: ( '*)' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5553:17: '*)'
+ {
+ match("*)");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CALL_END"
+
+ // $ANTLR start "RULE_CALL_START"
+ public final void mRULE_CALL_START() throws RecognitionException {
+ try {
+ int _type = RULE_CALL_START;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5555:17: ( '(*' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5555:19: '(*'
+ {
+ match("(*");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CALL_START"
+
+ // $ANTLR start "RULE_CATCH"
+ public final void mRULE_CATCH() throws RecognitionException {
+ try {
+ int _type = RULE_CATCH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5557:12: ( 'catch' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5557:14: 'catch'
+ {
+ match("catch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CATCH"
+
+ // $ANTLR start "RULE_CLASS"
+ public final void mRULE_CLASS() throws RecognitionException {
+ try {
+ int _type = RULE_CLASS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5559:12: ( 'class' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5559:14: 'class'
+ {
+ match("class");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_CLASS"
+
+ // $ANTLR start "RULE_COLON"
+ public final void mRULE_COLON() throws RecognitionException {
+ try {
+ int _type = RULE_COLON;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5561:12: ( ':' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5561:14: ':'
+ {
+ match(':');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COLON"
+
+ // $ANTLR start "RULE_COLON_SLASH"
+ public final void mRULE_COLON_SLASH() throws RecognitionException {
+ try {
+ int _type = RULE_COLON_SLASH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5563:18: ( 'dummy COLON_SLASH' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5563:20: 'dummy COLON_SLASH'
+ {
+ match("dummy COLON_SLASH");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COLON_SLASH"
+
+ // $ANTLR start "RULE_COMMA"
+ public final void mRULE_COMMA() throws RecognitionException {
+ try {
+ int _type = RULE_COMMA;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5565:12: ( ',' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5565:14: ','
+ {
+ match(',');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMMA"
+
+ // $ANTLR start "RULE_DOT"
+ public final void mRULE_DOT() throws RecognitionException {
+ try {
+ int _type = RULE_DOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5567:10: ( '.' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5567:12: '.'
+ {
+ match('.');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DOT"
+
+ // $ANTLR start "RULE_ELSE"
+ public final void mRULE_ELSE() throws RecognitionException {
+ try {
+ int _type = RULE_ELSE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5569:11: ( 'else' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5569:13: 'else'
+ {
+ match("else");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ELSE"
+
+ // $ANTLR start "RULE_EQUAL"
+ public final void mRULE_EQUAL() throws RecognitionException {
+ try {
+ int _type = RULE_EQUAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5571:12: ( '=' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5571:14: '='
+ {
+ match('=');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_EQUAL"
+
+ // $ANTLR start "RULE_EXTENDS"
+ public final void mRULE_EXTENDS() throws RecognitionException {
+ try {
+ int _type = RULE_EXTENDS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5573:14: ( 'extends' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5573:16: 'extends'
+ {
+ match("extends");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_EXTENDS"
+
+ // $ANTLR start "RULE_FINALLY"
+ public final void mRULE_FINALLY() throws RecognitionException {
+ try {
+ int _type = RULE_FINALLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5575:14: ( 'finally' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5575:16: 'finally'
+ {
+ match("finally");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FINALLY"
+
+ // $ANTLR start "RULE_FOR"
+ public final void mRULE_FOR() throws RecognitionException {
+ try {
+ int _type = RULE_FOR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5577:10: ( 'for' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5577:12: 'for'
+ {
+ match("for");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FOR"
+
+ // $ANTLR start "RULE_FORIN"
+ public final void mRULE_FORIN() throws RecognitionException {
+ try {
+ int _type = RULE_FORIN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5579:12: ( 'in' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5579:14: 'in'
+ {
+ match("in");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FORIN"
+
+ // $ANTLR start "RULE_FOROF"
+ public final void mRULE_FOROF() throws RecognitionException {
+ try {
+ int _type = RULE_FOROF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5581:12: ( 'of' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5581:14: 'of'
+ {
+ match("of");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FOROF"
+
+ // $ANTLR start "RULE_FUNC_EXIST"
+ public final void mRULE_FUNC_EXIST() throws RecognitionException {
+ try {
+ int _type = RULE_FUNC_EXIST;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5583:17: ( 'dummy FUNC_EXIST' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5583:19: 'dummy FUNC_EXIST'
+ {
+ match("dummy FUNC_EXIST");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_FUNC_EXIST"
+
+ // $ANTLR start "RULE_HERECOMMENT"
+ public final void mRULE_HERECOMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_HERECOMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5585:18: ( 'dummy HERECOMMENT' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5585:20: 'dummy HERECOMMENT'
+ {
+ match("dummy HERECOMMENT");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_HERECOMMENT"
+
+ // $ANTLR start "RULE_IF"
+ public final void mRULE_IF() throws RecognitionException {
+ try {
+ int _type = RULE_IF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5587:9: ( ( 'if' | 'unless' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5587:11: ( 'if' | 'unless' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5587:11: ( 'if' | 'unless' )
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0=='i') ) {
+ alt5=1;
+ }
+ else if ( (LA5_0=='u') ) {
+ alt5=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 5, 0, input);
+
+ throw nvae;
+ }
+ switch (alt5) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5587:12: 'if'
+ {
+ match("if");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5587:17: 'unless'
+ {
+ match("unless");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_IF"
+
+ // $ANTLR start "RULE_INDENT"
+ public final void mRULE_INDENT() throws RecognitionException {
+ try {
+ int _type = RULE_INDENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5589:13: ( '{*' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5589:15: '{*'
+ {
+ match("{*");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDENT"
+
+ // $ANTLR start "RULE_INDEX_END"
+ public final void mRULE_INDEX_END() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_END;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5591:16: ( '*]' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5591:18: '*]'
+ {
+ match("*]");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_END"
+
+ // $ANTLR start "RULE_INDEX_PROTO"
+ public final void mRULE_INDEX_PROTO() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_PROTO;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5593:18: ( 'dummy INDEX_PROTO' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5593:20: 'dummy INDEX_PROTO'
+ {
+ match("dummy INDEX_PROTO");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_PROTO"
+
+ // $ANTLR start "RULE_INDEX_SOAK"
+ public final void mRULE_INDEX_SOAK() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_SOAK;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5595:17: ( 'dummy INDEX_SOAK' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5595:19: 'dummy INDEX_SOAK'
+ {
+ match("dummy INDEX_SOAK");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_SOAK"
+
+ // $ANTLR start "RULE_INDEX_START"
+ public final void mRULE_INDEX_START() throws RecognitionException {
+ try {
+ int _type = RULE_INDEX_START;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5597:18: ( '[*' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5597:20: '[*'
+ {
+ match("[*");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDEX_START"
+
+ // $ANTLR start "RULE_JS"
+ public final void mRULE_JS() throws RecognitionException {
+ try {
+ int _type = RULE_JS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5599:9: ( 'dummy JS' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5599:11: 'dummy JS'
+ {
+ match("dummy JS");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_JS"
+
+ // $ANTLR start "RULE_LBRACKET"
+ public final void mRULE_LBRACKET() throws RecognitionException {
+ try {
+ int _type = RULE_LBRACKET;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5601:15: ( '[' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5601:17: '['
+ {
+ match('[');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LBRACKET"
+
+ // $ANTLR start "RULE_LCURLY"
+ public final void mRULE_LCURLY() throws RecognitionException {
+ try {
+ int _type = RULE_LCURLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5603:13: ( 'dummy LCURLY' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5603:15: 'dummy LCURLY'
+ {
+ match("dummy LCURLY");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LCURLY"
+
+ // $ANTLR start "RULE_LEADING_WHEN"
+ public final void mRULE_LEADING_WHEN() throws RecognitionException {
+ try {
+ int _type = RULE_LEADING_WHEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5605:19: ( 'dummy LEADING_WHEN' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5605:21: 'dummy LEADING_WHEN'
+ {
+ match("dummy LEADING_WHEN");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LEADING_WHEN"
+
+ // $ANTLR start "RULE_LOGIC"
+ public final void mRULE_LOGIC() throws RecognitionException {
+ try {
+ int _type = RULE_LOGIC;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5607:12: ( ( '&&' | '||' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5607:14: ( '&&' | '||' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5607:14: ( '&&' | '||' )
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0=='&') ) {
+ alt6=1;
+ }
+ else if ( (LA6_0=='|') ) {
+ alt6=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 6, 0, input);
+
+ throw nvae;
+ }
+ switch (alt6) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5607:15: '&&'
+ {
+ match("&&");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5607:20: '||'
+ {
+ match("||");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOGIC"
+
+ // $ANTLR start "RULE_LOOP"
+ public final void mRULE_LOOP() throws RecognitionException {
+ try {
+ int _type = RULE_LOOP;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5609:11: ( 'loop' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5609:13: 'loop'
+ {
+ match("loop");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOOP"
+
+ // $ANTLR start "RULE_LPAREN"
+ public final void mRULE_LPAREN() throws RecognitionException {
+ try {
+ int _type = RULE_LPAREN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5611:13: ( '(' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5611:15: '('
+ {
+ match('(');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LPAREN"
+
+ // $ANTLR start "RULE_MATH"
+ public final void mRULE_MATH() throws RecognitionException {
+ try {
+ int _type = RULE_MATH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5613:11: ( ( '*' | '/' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5613:13: ( '*' | '/' )
+ {
+ if ( input.LA(1)=='*'||input.LA(1)=='/' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_MATH"
+
+ // $ANTLR start "RULE_MINUS"
+ public final void mRULE_MINUS() throws RecognitionException {
+ try {
+ int _type = RULE_MINUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5615:12: ( '-' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5615:14: '-'
+ {
+ match('-');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_MINUS"
+
+ // $ANTLR start "RULE_NEW"
+ public final void mRULE_NEW() throws RecognitionException {
+ try {
+ int _type = RULE_NEW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5617:10: ( 'new' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5617:12: 'new'
+ {
+ match("new");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_NEW"
+
+ // $ANTLR start "RULE_NUMBER"
+ public final void mRULE_NUMBER() throws RecognitionException {
+ try {
+ int _type = RULE_NUMBER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5619:13: ( ( '0' .. '9' )+ )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5619:15: ( '0' .. '9' )+
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5619:15: ( '0' .. '9' )+
+ int cnt7=0;
+ loop7:
+ do {
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( ((LA7_0>='0' && LA7_0<='9')) ) {
+ alt7=1;
+ }
+
+
+ switch (alt7) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5619:16: '0' .. '9'
+ {
+ matchRange('0','9');
+
+ }
+ break;
+
+ default :
+ if ( cnt7 >= 1 ) break loop7;
+ EarlyExitException eee =
+ new EarlyExitException(7, input);
+ throw eee;
+ }
+ cnt7++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_NUMBER"
+
+ // $ANTLR start "RULE_OUTDENT"
+ public final void mRULE_OUTDENT() throws RecognitionException {
+ try {
+ int _type = RULE_OUTDENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5621:14: ( '*}' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5621:16: '*}'
+ {
+ match("*}");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_OUTDENT"
+
+ // $ANTLR start "RULE_OWN"
+ public final void mRULE_OWN() throws RecognitionException {
+ try {
+ int _type = RULE_OWN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5623:10: ( 'own' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5623:12: 'own'
+ {
+ match("own");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_OWN"
+
+ // $ANTLR start "RULE_PLUS"
+ public final void mRULE_PLUS() throws RecognitionException {
+ try {
+ int _type = RULE_PLUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5625:11: ( '+' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5625:13: '+'
+ {
+ match('+');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_PLUS"
+
+ // $ANTLR start "RULE_POST_IF"
+ public final void mRULE_POST_IF() throws RecognitionException {
+ try {
+ int _type = RULE_POST_IF;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5627:14: ( 'dummy POST_IF' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5627:16: 'dummy POST_IF'
+ {
+ match("dummy POST_IF");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_POST_IF"
+
+ // $ANTLR start "RULE_QUESTION"
+ public final void mRULE_QUESTION() throws RecognitionException {
+ try {
+ int _type = RULE_QUESTION;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5629:15: ( '?' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5629:17: '?'
+ {
+ match('?');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_QUESTION"
+
+ // $ANTLR start "RULE_QUESTION_DOT"
+ public final void mRULE_QUESTION_DOT() throws RecognitionException {
+ try {
+ int _type = RULE_QUESTION_DOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5631:19: ( '?.' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5631:21: '?.'
+ {
+ match("?.");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_QUESTION_DOT"
+
+ // $ANTLR start "RULE_RBRACKET"
+ public final void mRULE_RBRACKET() throws RecognitionException {
+ try {
+ int _type = RULE_RBRACKET;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5633:15: ( ']' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5633:17: ']'
+ {
+ match(']');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RBRACKET"
+
+ // $ANTLR start "RULE_RCURLY"
+ public final void mRULE_RCURLY() throws RecognitionException {
+ try {
+ int _type = RULE_RCURLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5635:13: ( 'dummy RCURLY' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5635:15: 'dummy RCURLY'
+ {
+ match("dummy RCURLY");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RCURLY"
+
+ // $ANTLR start "RULE_REGEX"
+ public final void mRULE_REGEX() throws RecognitionException {
+ try {
+ int _type = RULE_REGEX;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5637:12: ( '///' ( options {greedy=false; } : . )* '///' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5637:14: '///' ( options {greedy=false; } : . )* '///'
+ {
+ match("///");
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5637:20: ( options {greedy=false; } : . )*
+ loop8:
+ do {
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='/') ) {
+ int LA8_1 = input.LA(2);
+
+ if ( (LA8_1=='/') ) {
+ int LA8_3 = input.LA(3);
+
+ if ( (LA8_3=='/') ) {
+ alt8=2;
+ }
+ else if ( ((LA8_3>='\u0000' && LA8_3<='.')||(LA8_3>='0' && LA8_3<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ }
+ else if ( ((LA8_1>='\u0000' && LA8_1<='.')||(LA8_1>='0' && LA8_1<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ }
+ else if ( ((LA8_0>='\u0000' && LA8_0<='.')||(LA8_0>='0' && LA8_0<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ switch (alt8) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5637:48: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop8;
+ }
+ } while (true);
+
+ match("///");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_REGEX"
+
+ // $ANTLR start "RULE_RELATION"
+ public final void mRULE_RELATION() throws RecognitionException {
+ try {
+ int _type = RULE_RELATION;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5639:15: ( ( 'in' | 'of' | 'instanceof' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5639:17: ( 'in' | 'of' | 'instanceof' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5639:17: ( 'in' | 'of' | 'instanceof' )
+ int alt9=3;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0=='i') ) {
+ int LA9_1 = input.LA(2);
+
+ if ( (LA9_1=='n') ) {
+ int LA9_3 = input.LA(3);
+
+ if ( (LA9_3=='s') ) {
+ alt9=3;
+ }
+ else {
+ alt9=1;}
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA9_0=='o') ) {
+ alt9=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 0, input);
+
+ throw nvae;
+ }
+ switch (alt9) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5639:18: 'in'
+ {
+ match("in");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5639:23: 'of'
+ {
+ match("of");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5639:28: 'instanceof'
+ {
+ match("instanceof");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RELATION"
+
+ // $ANTLR start "RULE_RETURN"
+ public final void mRULE_RETURN() throws RecognitionException {
+ try {
+ int _type = RULE_RETURN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5641:13: ( 'return' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5641:15: 'return'
+ {
+ match("return");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RETURN"
+
+ // $ANTLR start "RULE_RPAREN"
+ public final void mRULE_RPAREN() throws RecognitionException {
+ try {
+ int _type = RULE_RPAREN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5643:13: ( ')' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5643:15: ')'
+ {
+ match(')');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_RPAREN"
+
+ // $ANTLR start "RULE_STATEMENT"
+ public final void mRULE_STATEMENT() throws RecognitionException {
+ try {
+ int _type = RULE_STATEMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5645:16: ( ( 'break' | 'continue' | 'debugger' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5645:18: ( 'break' | 'continue' | 'debugger' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5645:18: ( 'break' | 'continue' | 'debugger' )
+ int alt10=3;
+ switch ( input.LA(1) ) {
+ case 'b':
+ {
+ alt10=1;
+ }
+ break;
+ case 'c':
+ {
+ alt10=2;
+ }
+ break;
+ case 'd':
+ {
+ alt10=3;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 10, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt10) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5645:19: 'break'
+ {
+ match("break");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5645:27: 'continue'
+ {
+ match("continue");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5645:38: 'debugger'
+ {
+ match("debugger");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STATEMENT"
+
+ // $ANTLR start "RULE_STRING"
+ public final void mRULE_STRING() throws RecognitionException {
+ try {
+ int _type = RULE_STRING;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:13: ( ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:15: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:15: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"' )
+ int alt17=4;
+ int LA17_0 = input.LA(1);
+
+ if ( (LA17_0=='\'') ) {
+ int LA17_1 = input.LA(2);
+
+ if ( (LA17_1=='\'') ) {
+ int LA17_3 = input.LA(3);
+
+ if ( (LA17_3=='\'') ) {
+ alt17=1;
+ }
+ else {
+ alt17=2;}
+ }
+ else if ( ((LA17_1>='\u0000' && LA17_1<='&')||(LA17_1>='(' && LA17_1<='\uFFFF')) ) {
+ alt17=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA17_0=='\"') ) {
+ int LA17_2 = input.LA(2);
+
+ if ( (LA17_2=='\"') ) {
+ int LA17_5 = input.LA(3);
+
+ if ( (LA17_5=='\"') ) {
+ alt17=3;
+ }
+ else {
+ alt17=4;}
+ }
+ else if ( ((LA17_2>='\u0000' && LA17_2<='!')||(LA17_2>='#' && LA17_2<='\uFFFF')) ) {
+ alt17=4;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 2, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 17, 0, input);
+
+ throw nvae;
+ }
+ switch (alt17) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:16: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
+ {
+ match("'''");
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:25: ( options {greedy=false; } : . )*
+ loop11:
+ do {
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0=='\'') ) {
+ int LA11_1 = input.LA(2);
+
+ if ( (LA11_1=='\'') ) {
+ int LA11_3 = input.LA(3);
+
+ if ( (LA11_3=='\'') ) {
+ alt11=2;
+ }
+ else if ( ((LA11_3>='\u0000' && LA11_3<='&')||(LA11_3>='(' && LA11_3<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ }
+ else if ( ((LA11_1>='\u0000' && LA11_1<='&')||(LA11_1>='(' && LA11_1<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ }
+ else if ( ((LA11_0>='\u0000' && LA11_0<='&')||(LA11_0>='(' && LA11_0<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ switch (alt11) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:53: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop11;
+ }
+ } while (true);
+
+ match("'''");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:66: '\\'' (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )? '\\''
+ {
+ match('\'');
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:71: (~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )* )?
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( ((LA13_0>='\u0000' && LA13_0<='&')||(LA13_0>='(' && LA13_0<='\uFFFF')) ) {
+ alt13=1;
+ }
+ switch (alt13) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:72: ~ ( '\\'' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )*
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:80: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\\'' ) ) )*
+ loop12:
+ do {
+ int alt12=3;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0=='\\') ) {
+ alt12=1;
+ }
+ else if ( ((LA12_0>='\u0000' && LA12_0<='&')||(LA12_0>='(' && LA12_0<='[')||(LA12_0>=']' && LA12_0<='\uFFFF')) ) {
+ alt12=2;
+ }
+
+
+ switch (alt12) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:81: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' )
+ {
+ match('\\');
+ if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||(input.LA(1)>='t' && input.LA(1)<='u') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:126: ~ ( ( '\\\\' | '\\'' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop12;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ match('\'');
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:150: '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"'
+ {
+ match("\"\"\"");
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:156: ( options {greedy=false; } : . )*
+ loop14:
+ do {
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0=='\"') ) {
+ int LA14_1 = input.LA(2);
+
+ if ( (LA14_1=='\"') ) {
+ int LA14_3 = input.LA(3);
+
+ if ( (LA14_3=='\"') ) {
+ alt14=2;
+ }
+ else if ( ((LA14_3>='\u0000' && LA14_3<='!')||(LA14_3>='#' && LA14_3<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ }
+ else if ( ((LA14_1>='\u0000' && LA14_1<='!')||(LA14_1>='#' && LA14_1<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ }
+ else if ( ((LA14_0>='\u0000' && LA14_0<='!')||(LA14_0>='#' && LA14_0<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ switch (alt14) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:184: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop14;
+ }
+ } while (true);
+
+ match("\"\"\"");
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:194: '\"' (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )? '\"'
+ {
+ match('\"');
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:198: (~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* )?
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( ((LA16_0>='\u0000' && LA16_0<='!')||(LA16_0>='#' && LA16_0<='\uFFFF')) ) {
+ alt16=1;
+ }
+ switch (alt16) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:199: ~ ( '\"' ) ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )*
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:206: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )*
+ loop15:
+ do {
+ int alt15=3;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0=='\\') ) {
+ alt15=1;
+ }
+ else if ( ((LA15_0>='\u0000' && LA15_0<='!')||(LA15_0>='#' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) {
+ alt15=2;
+ }
+
+
+ switch (alt15) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:207: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' )
+ {
+ match('\\');
+ if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||(input.LA(1)>='t' && input.LA(1)<='u') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5647:252: ~ ( ( '\\\\' | '\"' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop15;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ match('\"');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STRING"
+
+ // $ANTLR start "RULE_SUPER"
+ public final void mRULE_SUPER() throws RecognitionException {
+ try {
+ int _type = RULE_SUPER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5649:12: ( 'super' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5649:14: 'super'
+ {
+ match("super");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SUPER"
+
+ // $ANTLR start "RULE_SWITCH"
+ public final void mRULE_SWITCH() throws RecognitionException {
+ try {
+ int _type = RULE_SWITCH;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5651:13: ( 'switch' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5651:15: 'switch'
+ {
+ match("switch");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SWITCH"
+
+ // $ANTLR start "RULE_TERMINATOR"
+ public final void mRULE_TERMINATOR() throws RecognitionException {
+ try {
+ int _type = RULE_TERMINATOR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5653:17: ( ( '\\n' )+ )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5653:19: ( '\\n' )+
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5653:19: ( '\\n' )+
+ int cnt18=0;
+ loop18:
+ do {
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0=='\n') ) {
+ alt18=1;
+ }
+
+
+ switch (alt18) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5653:19: '\\n'
+ {
+ match('\n');
+
+ }
+ break;
+
+ default :
+ if ( cnt18 >= 1 ) break loop18;
+ EarlyExitException eee =
+ new EarlyExitException(18, input);
+ throw eee;
+ }
+ cnt18++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_TERMINATOR"
+
+ // $ANTLR start "RULE_THEN"
+ public final void mRULE_THEN() throws RecognitionException {
+ try {
+ int _type = RULE_THEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5655:11: ( 'then' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5655:13: 'then'
+ {
+ match("then");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_THEN"
+
+ // $ANTLR start "RULE_THIS"
+ public final void mRULE_THIS() throws RecognitionException {
+ try {
+ int _type = RULE_THIS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5657:11: ( 'this' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5657:13: 'this'
+ {
+ match("this");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_THIS"
+
+ // $ANTLR start "RULE_THROW"
+ public final void mRULE_THROW() throws RecognitionException {
+ try {
+ int _type = RULE_THROW;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5659:12: ( 'throw' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5659:14: 'throw'
+ {
+ match("throw");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_THROW"
+
+ // $ANTLR start "RULE_TRY"
+ public final void mRULE_TRY() throws RecognitionException {
+ try {
+ int _type = RULE_TRY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5661:10: ( 'try' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5661:12: 'try'
+ {
+ match("try");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_TRY"
+
+ // $ANTLR start "RULE_UNARY"
+ public final void mRULE_UNARY() throws RecognitionException {
+ try {
+ int _type = RULE_UNARY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5663:12: ( ( '!' | '~' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5663:14: ( '!' | '~' )
+ {
+ if ( input.LA(1)=='!'||input.LA(1)=='~' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_UNARY"
+
+ // $ANTLR start "RULE_UNTIL"
+ public final void mRULE_UNTIL() throws RecognitionException {
+ try {
+ int _type = RULE_UNTIL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5665:12: ( 'until' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5665:14: 'until'
+ {
+ match("until");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_UNTIL"
+
+ // $ANTLR start "RULE_WHEN"
+ public final void mRULE_WHEN() throws RecognitionException {
+ try {
+ int _type = RULE_WHEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5667:11: ( 'when' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5667:13: 'when'
+ {
+ match("when");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WHEN"
+
+ // $ANTLR start "RULE_WHILE"
+ public final void mRULE_WHILE() throws RecognitionException {
+ try {
+ int _type = RULE_WHILE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5669:12: ( 'while' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5669:14: 'while'
+ {
+ match("while");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WHILE"
+
+ // $ANTLR start "RULE_LOGIC_WORD"
+ public final void mRULE_LOGIC_WORD() throws RecognitionException {
+ try {
+ int _type = RULE_LOGIC_WORD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5671:17: ( ( 'and' | 'or' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5671:19: ( 'and' | 'or' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5671:19: ( 'and' | 'or' )
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0=='a') ) {
+ alt19=1;
+ }
+ else if ( (LA19_0=='o') ) {
+ alt19=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 19, 0, input);
+
+ throw nvae;
+ }
+ switch (alt19) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5671:20: 'and'
+ {
+ match("and");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5671:26: 'or'
+ {
+ match("or");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOGIC_WORD"
+
+ // $ANTLR start "RULE_COMPARE_WORD"
+ public final void mRULE_COMPARE_WORD() throws RecognitionException {
+ try {
+ int _type = RULE_COMPARE_WORD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5673:19: ( ( 'isnt' | 'is' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5673:21: ( 'isnt' | 'is' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5673:21: ( 'isnt' | 'is' )
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0=='i') ) {
+ int LA20_1 = input.LA(2);
+
+ if ( (LA20_1=='s') ) {
+ int LA20_2 = input.LA(3);
+
+ if ( (LA20_2=='n') ) {
+ alt20=1;
+ }
+ else {
+ alt20=2;}
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 20, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 20, 0, input);
+
+ throw nvae;
+ }
+ switch (alt20) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5673:22: 'isnt'
+ {
+ match("isnt");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5673:29: 'is'
+ {
+ match("is");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COMPARE_WORD"
+
+ // $ANTLR start "RULE_UNARY_WORD"
+ public final void mRULE_UNARY_WORD() throws RecognitionException {
+ try {
+ int _type = RULE_UNARY_WORD;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5675:17: ( ( 'new' | 'do' | 'not' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5675:19: ( 'new' | 'do' | 'not' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5675:19: ( 'new' | 'do' | 'not' )
+ int alt21=3;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0=='n') ) {
+ int LA21_1 = input.LA(2);
+
+ if ( (LA21_1=='e') ) {
+ alt21=1;
+ }
+ else if ( (LA21_1=='o') ) {
+ alt21=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA21_0=='d') ) {
+ alt21=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 0, input);
+
+ throw nvae;
+ }
+ switch (alt21) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5675:20: 'new'
+ {
+ match("new");
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5675:26: 'do'
+ {
+ match("do");
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5675:31: 'not'
+ {
+ match("not");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_UNARY_WORD"
+
+ // $ANTLR start "RULE_ML_COMMENT"
+ public final void mRULE_ML_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_ML_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5677:17: ( '###' ~ ( '#' ) ( options {greedy=false; } : . )* '###' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5677:19: '###' ~ ( '#' ) ( options {greedy=false; } : . )* '###'
+ {
+ match("###");
+
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\"')||(input.LA(1)>='$' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5677:32: ( options {greedy=false; } : . )*
+ loop22:
+ do {
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( (LA22_0=='#') ) {
+ int LA22_1 = input.LA(2);
+
+ if ( (LA22_1=='#') ) {
+ int LA22_3 = input.LA(3);
+
+ if ( (LA22_3=='#') ) {
+ alt22=2;
+ }
+ else if ( ((LA22_3>='\u0000' && LA22_3<='\"')||(LA22_3>='$' && LA22_3<='\uFFFF')) ) {
+ alt22=1;
+ }
+
+
+ }
+ else if ( ((LA22_1>='\u0000' && LA22_1<='\"')||(LA22_1>='$' && LA22_1<='\uFFFF')) ) {
+ alt22=1;
+ }
+
+
+ }
+ else if ( ((LA22_0>='\u0000' && LA22_0<='\"')||(LA22_0>='$' && LA22_0<='\uFFFF')) ) {
+ alt22=1;
+ }
+
+
+ switch (alt22) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5677:60: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop22;
+ }
+ } while (true);
+
+ match("###");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ML_COMMENT"
+
+ // $ANTLR start "RULE_SL_COMMENT"
+ public final void mRULE_SL_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_SL_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5679:17: ( '#' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5679:19: '#' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+ {
+ match('#');
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5679:23: (~ ( ( '\\n' | '\\r' ) ) )*
+ loop23:
+ do {
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( ((LA23_0>='\u0000' && LA23_0<='\t')||(LA23_0>='\u000B' && LA23_0<='\f')||(LA23_0>='\u000E' && LA23_0<='\uFFFF')) ) {
+ alt23=1;
+ }
+
+
+ switch (alt23) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5679:23: ~ ( ( '\\n' | '\\r' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop23;
+ }
+ } while (true);
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5679:39: ( ( '\\r' )? '\\n' )?
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( (LA25_0=='\n'||LA25_0=='\r') ) {
+ alt25=1;
+ }
+ switch (alt25) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5679:40: ( '\\r' )? '\\n'
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5679:40: ( '\\r' )?
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0=='\r') ) {
+ alt24=1;
+ }
+ switch (alt24) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5679:40: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SL_COMMENT"
+
+ // $ANTLR start "RULE_WS"
+ public final void mRULE_WS() throws RecognitionException {
+ try {
+ int _type = RULE_WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5681:9: ( ( ' ' | '\\t' )+ )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5681:11: ( ' ' | '\\t' )+
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5681:11: ( ' ' | '\\t' )+
+ int cnt26=0;
+ loop26:
+ do {
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0=='\t'||LA26_0==' ') ) {
+ alt26=1;
+ }
+
+
+ switch (alt26) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:
+ {
+ if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt26 >= 1 ) break loop26;
+ EarlyExitException eee =
+ new EarlyExitException(26, input);
+ throw eee;
+ }
+ cnt26++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WS"
+
+ // $ANTLR start "RULE_IDENTIFIER"
+ public final void mRULE_IDENTIFIER() throws RecognitionException {
+ try {
+ int _type = RULE_IDENTIFIER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5683:17: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5683:19: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5683:19: ( '^' )?
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( (LA27_0=='^') ) {
+ alt27=1;
+ }
+ switch (alt27) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5683:19: '^'
+ {
+ match('^');
+
+ }
+ break;
+
+ }
+
+ if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5683:48: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ loop28:
+ do {
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( ((LA28_0>='0' && LA28_0<='9')||(LA28_0>='A' && LA28_0<='Z')||LA28_0=='_'||(LA28_0>='a' && LA28_0<='z')) ) {
+ alt28=1;
+ }
+
+
+ switch (alt28) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop28;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_IDENTIFIER"
+
+ public void mTokens() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:8: ( T__86 | RULE_TASK | RULE_ELLIPSIS | RULE_DOT_DOT | RULE_DOUBLE_COLON | RULE_SHIFT | RULE_BOUND_FUNC_ARROW | RULE_FUNC_ARROW | RULE_COMPARE | RULE_COMPOUND_ASSIGN | RULE_PLUS_PLUS | RULE_MINUS_MINUS | RULE_PARAM_END | RULE_PARAM_START | RULE_AT_SIGIL | RULE_BOOL | RULE_BY | RULE_CALL_END | RULE_CALL_START | RULE_CATCH | RULE_CLASS | RULE_COLON | RULE_COLON_SLASH | RULE_COMMA | RULE_DOT | RULE_ELSE | RULE_EQUAL | RULE_EXTENDS | RULE_FINALLY | RULE_FOR | RULE_FORIN | RULE_FOROF | RULE_FUNC_EXIST | RULE_HERECOMMENT | RULE_IF | RULE_INDENT | RULE_INDEX_END | RULE_INDEX_PROTO | RULE_INDEX_SOAK | RULE_INDEX_START | RULE_JS | RULE_LBRACKET | RULE_LCURLY | RULE_LEADING_WHEN | RULE_LOGIC | RULE_LOOP | RULE_LPAREN | RULE_MATH | RULE_MINUS | RULE_NEW | RULE_NUMBER | RULE_OUTDENT | RULE_OWN | RULE_PLUS | RULE_POST_IF | RULE_QUESTION | RULE_QUESTION_DOT | RULE_RBRACKET | RULE_RCURLY | RULE_REGEX | RULE_RELATION | RULE_RETURN | RULE_RPAREN | RULE_STATEMENT | RULE_STRING | RULE_SUPER | RULE_SWITCH | RULE_TERMINATOR | RULE_THEN | RULE_THIS | RULE_THROW | RULE_TRY | RULE_UNARY | RULE_UNTIL | RULE_WHEN | RULE_WHILE | RULE_LOGIC_WORD | RULE_COMPARE_WORD | RULE_UNARY_WORD | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_IDENTIFIER )
+ int alt29=83;
+ alt29 = dfa29.predict(input);
+ switch (alt29) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:10: T__86
+ {
+ mT__86();
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:16: RULE_TASK
+ {
+ mRULE_TASK();
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:26: RULE_ELLIPSIS
+ {
+ mRULE_ELLIPSIS();
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:40: RULE_DOT_DOT
+ {
+ mRULE_DOT_DOT();
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:53: RULE_DOUBLE_COLON
+ {
+ mRULE_DOUBLE_COLON();
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:71: RULE_SHIFT
+ {
+ mRULE_SHIFT();
+
+ }
+ break;
+ case 7 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:82: RULE_BOUND_FUNC_ARROW
+ {
+ mRULE_BOUND_FUNC_ARROW();
+
+ }
+ break;
+ case 8 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:104: RULE_FUNC_ARROW
+ {
+ mRULE_FUNC_ARROW();
+
+ }
+ break;
+ case 9 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:120: RULE_COMPARE
+ {
+ mRULE_COMPARE();
+
+ }
+ break;
+ case 10 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:133: RULE_COMPOUND_ASSIGN
+ {
+ mRULE_COMPOUND_ASSIGN();
+
+ }
+ break;
+ case 11 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:154: RULE_PLUS_PLUS
+ {
+ mRULE_PLUS_PLUS();
+
+ }
+ break;
+ case 12 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:169: RULE_MINUS_MINUS
+ {
+ mRULE_MINUS_MINUS();
+
+ }
+ break;
+ case 13 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:186: RULE_PARAM_END
+ {
+ mRULE_PARAM_END();
+
+ }
+ break;
+ case 14 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:201: RULE_PARAM_START
+ {
+ mRULE_PARAM_START();
+
+ }
+ break;
+ case 15 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:218: RULE_AT_SIGIL
+ {
+ mRULE_AT_SIGIL();
+
+ }
+ break;
+ case 16 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:232: RULE_BOOL
+ {
+ mRULE_BOOL();
+
+ }
+ break;
+ case 17 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:242: RULE_BY
+ {
+ mRULE_BY();
+
+ }
+ break;
+ case 18 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:250: RULE_CALL_END
+ {
+ mRULE_CALL_END();
+
+ }
+ break;
+ case 19 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:264: RULE_CALL_START
+ {
+ mRULE_CALL_START();
+
+ }
+ break;
+ case 20 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:280: RULE_CATCH
+ {
+ mRULE_CATCH();
+
+ }
+ break;
+ case 21 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:291: RULE_CLASS
+ {
+ mRULE_CLASS();
+
+ }
+ break;
+ case 22 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:302: RULE_COLON
+ {
+ mRULE_COLON();
+
+ }
+ break;
+ case 23 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:313: RULE_COLON_SLASH
+ {
+ mRULE_COLON_SLASH();
+
+ }
+ break;
+ case 24 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:330: RULE_COMMA
+ {
+ mRULE_COMMA();
+
+ }
+ break;
+ case 25 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:341: RULE_DOT
+ {
+ mRULE_DOT();
+
+ }
+ break;
+ case 26 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:350: RULE_ELSE
+ {
+ mRULE_ELSE();
+
+ }
+ break;
+ case 27 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:360: RULE_EQUAL
+ {
+ mRULE_EQUAL();
+
+ }
+ break;
+ case 28 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:371: RULE_EXTENDS
+ {
+ mRULE_EXTENDS();
+
+ }
+ break;
+ case 29 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:384: RULE_FINALLY
+ {
+ mRULE_FINALLY();
+
+ }
+ break;
+ case 30 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:397: RULE_FOR
+ {
+ mRULE_FOR();
+
+ }
+ break;
+ case 31 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:406: RULE_FORIN
+ {
+ mRULE_FORIN();
+
+ }
+ break;
+ case 32 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:417: RULE_FOROF
+ {
+ mRULE_FOROF();
+
+ }
+ break;
+ case 33 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:428: RULE_FUNC_EXIST
+ {
+ mRULE_FUNC_EXIST();
+
+ }
+ break;
+ case 34 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:444: RULE_HERECOMMENT
+ {
+ mRULE_HERECOMMENT();
+
+ }
+ break;
+ case 35 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:461: RULE_IF
+ {
+ mRULE_IF();
+
+ }
+ break;
+ case 36 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:469: RULE_INDENT
+ {
+ mRULE_INDENT();
+
+ }
+ break;
+ case 37 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:481: RULE_INDEX_END
+ {
+ mRULE_INDEX_END();
+
+ }
+ break;
+ case 38 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:496: RULE_INDEX_PROTO
+ {
+ mRULE_INDEX_PROTO();
+
+ }
+ break;
+ case 39 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:513: RULE_INDEX_SOAK
+ {
+ mRULE_INDEX_SOAK();
+
+ }
+ break;
+ case 40 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:529: RULE_INDEX_START
+ {
+ mRULE_INDEX_START();
+
+ }
+ break;
+ case 41 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:546: RULE_JS
+ {
+ mRULE_JS();
+
+ }
+ break;
+ case 42 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:554: RULE_LBRACKET
+ {
+ mRULE_LBRACKET();
+
+ }
+ break;
+ case 43 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:568: RULE_LCURLY
+ {
+ mRULE_LCURLY();
+
+ }
+ break;
+ case 44 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:580: RULE_LEADING_WHEN
+ {
+ mRULE_LEADING_WHEN();
+
+ }
+ break;
+ case 45 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:598: RULE_LOGIC
+ {
+ mRULE_LOGIC();
+
+ }
+ break;
+ case 46 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:609: RULE_LOOP
+ {
+ mRULE_LOOP();
+
+ }
+ break;
+ case 47 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:619: RULE_LPAREN
+ {
+ mRULE_LPAREN();
+
+ }
+ break;
+ case 48 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:631: RULE_MATH
+ {
+ mRULE_MATH();
+
+ }
+ break;
+ case 49 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:641: RULE_MINUS
+ {
+ mRULE_MINUS();
+
+ }
+ break;
+ case 50 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:652: RULE_NEW
+ {
+ mRULE_NEW();
+
+ }
+ break;
+ case 51 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:661: RULE_NUMBER
+ {
+ mRULE_NUMBER();
+
+ }
+ break;
+ case 52 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:673: RULE_OUTDENT
+ {
+ mRULE_OUTDENT();
+
+ }
+ break;
+ case 53 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:686: RULE_OWN
+ {
+ mRULE_OWN();
+
+ }
+ break;
+ case 54 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:695: RULE_PLUS
+ {
+ mRULE_PLUS();
+
+ }
+ break;
+ case 55 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:705: RULE_POST_IF
+ {
+ mRULE_POST_IF();
+
+ }
+ break;
+ case 56 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:718: RULE_QUESTION
+ {
+ mRULE_QUESTION();
+
+ }
+ break;
+ case 57 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:732: RULE_QUESTION_DOT
+ {
+ mRULE_QUESTION_DOT();
+
+ }
+ break;
+ case 58 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:750: RULE_RBRACKET
+ {
+ mRULE_RBRACKET();
+
+ }
+ break;
+ case 59 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:764: RULE_RCURLY
+ {
+ mRULE_RCURLY();
+
+ }
+ break;
+ case 60 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:776: RULE_REGEX
+ {
+ mRULE_REGEX();
+
+ }
+ break;
+ case 61 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:787: RULE_RELATION
+ {
+ mRULE_RELATION();
+
+ }
+ break;
+ case 62 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:801: RULE_RETURN
+ {
+ mRULE_RETURN();
+
+ }
+ break;
+ case 63 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:813: RULE_RPAREN
+ {
+ mRULE_RPAREN();
+
+ }
+ break;
+ case 64 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:825: RULE_STATEMENT
+ {
+ mRULE_STATEMENT();
+
+ }
+ break;
+ case 65 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:840: RULE_STRING
+ {
+ mRULE_STRING();
+
+ }
+ break;
+ case 66 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:852: RULE_SUPER
+ {
+ mRULE_SUPER();
+
+ }
+ break;
+ case 67 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:863: RULE_SWITCH
+ {
+ mRULE_SWITCH();
+
+ }
+ break;
+ case 68 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:875: RULE_TERMINATOR
+ {
+ mRULE_TERMINATOR();
+
+ }
+ break;
+ case 69 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:891: RULE_THEN
+ {
+ mRULE_THEN();
+
+ }
+ break;
+ case 70 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:901: RULE_THIS
+ {
+ mRULE_THIS();
+
+ }
+ break;
+ case 71 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:911: RULE_THROW
+ {
+ mRULE_THROW();
+
+ }
+ break;
+ case 72 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:922: RULE_TRY
+ {
+ mRULE_TRY();
+
+ }
+ break;
+ case 73 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:931: RULE_UNARY
+ {
+ mRULE_UNARY();
+
+ }
+ break;
+ case 74 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:942: RULE_UNTIL
+ {
+ mRULE_UNTIL();
+
+ }
+ break;
+ case 75 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:953: RULE_WHEN
+ {
+ mRULE_WHEN();
+
+ }
+ break;
+ case 76 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:963: RULE_WHILE
+ {
+ mRULE_WHILE();
+
+ }
+ break;
+ case 77 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:974: RULE_LOGIC_WORD
+ {
+ mRULE_LOGIC_WORD();
+
+ }
+ break;
+ case 78 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:990: RULE_COMPARE_WORD
+ {
+ mRULE_COMPARE_WORD();
+
+ }
+ break;
+ case 79 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:1008: RULE_UNARY_WORD
+ {
+ mRULE_UNARY_WORD();
+
+ }
+ break;
+ case 80 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:1024: RULE_ML_COMMENT
+ {
+ mRULE_ML_COMMENT();
+
+ }
+ break;
+ case 81 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:1040: RULE_SL_COMMENT
+ {
+ mRULE_SL_COMMENT();
+
+ }
+ break;
+ case 82 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:1056: RULE_WS
+ {
+ mRULE_WS();
+
+ }
+ break;
+ case 83 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1:1064: RULE_IDENTIFIER
+ {
+ mRULE_IDENTIFIER();
+
+ }
+ break;
+
+ }
+
+ }
+
+
+ protected DFA4 dfa4 = new DFA4(this);
+ protected DFA29 dfa29 = new DFA29(this);
+ static final String DFA4_eotS =
+ "\13\uffff";
+ static final String DFA4_eofS =
+ "\13\uffff";
+ static final String DFA4_minS =
+ "\1\146\3\uffff\1\157\1\146\5\uffff";
+ static final String DFA4_maxS =
+ "\1\171\3\uffff\1\165\1\156\5\uffff";
+ static final String DFA4_acceptS =
+ "\1\uffff\1\1\1\2\1\3\2\uffff\1\7\1\4\1\6\1\5\1\10";
+ static final String DFA4_specialS =
+ "\13\uffff}>";
+ static final String[] DFA4_transitionS = {
+ "\1\2\7\uffff\1\4\1\5\4\uffff\1\1\1\3\3\uffff\1\6",
+ "",
+ "",
+ "",
+ "\1\10\5\uffff\1\7",
+ "\1\12\7\uffff\1\11",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
+ static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
+ static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
+ static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
+ static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
+ static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
+ static final short[][] DFA4_transition;
+
+ static {
+ int numStates = DFA4_transitionS.length;
+ DFA4_transition = new short[numStates][];
+ for (int i=0; i";
+ static final String[] DFA29_transitionS = {
+ "\1\51\1\44\25\uffff\1\51\1\11\1\42\1\50\2\uffff\1\33\1\42\1"+
+ "\14\1\41\1\13\1\12\1\26\1\10\1\3\1\35\12\36\1\4\1\uffff\1\5"+
+ "\1\7\1\6\1\37\1\15\32\52\1\32\1\uffff\1\40\2\52\1\uffff\1\47"+
+ "\1\23\1\24\1\25\1\27\1\16\2\52\1\30\2\52\1\34\1\52\1\20\1\21"+
+ "\2\52\1\1\1\43\1\2\1\17\1\52\1\46\1\52\1\22\1\52\1\31\1\33\1"+
+ "\uffff\1\45",
+ "\1\53",
+ "\1\54\6\uffff\1\56\11\uffff\1\55",
+ "\1\57",
+ "\1\61",
+ "\1\63",
+ "\1\63",
+ "\1\64\1\65",
+ "\1\71\17\uffff\1\70\1\67",
+ "\1\64",
+ "\1\73\21\uffff\1\70",
+ "\1\76\1\75\62\uffff\1\77\37\uffff\1\100",
+ "\1\102",
+ "",
+ "\1\104\7\uffff\1\105\5\uffff\1\106",
+ "\1\107",
+ "\1\112\11\uffff\1\111\5\uffff\1\110",
+ "\1\114\7\uffff\1\113\3\uffff\1\116\4\uffff\1\115",
+ "\1\117",
+ "\1\121\6\uffff\1\120",
+ "\1\122\12\uffff\1\123\2\uffff\1\124",
+ "\1\126\11\uffff\1\127\5\uffff\1\125",
+ "",
+ "\1\130\13\uffff\1\131",
+ "\1\133\7\uffff\1\132\4\uffff\1\134",
+ "",
+ "\1\135",
+ "",
+ "\1\137",
+ "\1\140",
+ "",
+ "\1\141",
+ "",
+ "",
+ "",
+ "\1\143\1\uffff\1\144",
+ "",
+ "",
+ "\1\145",
+ "\1\146",
+ "\1\147",
+ "",
+ "",
+ "\1\151\2\uffff\1\152",
+ "\1\153",
+ "\1\154\3\uffff\1\155",
+ "\1\156\3\uffff\1\157\10\uffff\1\160",
+ "\1\161",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\163",
+ "",
+ "\1\165",
+ "\1\166",
+ "\1\167",
+ "\1\170\7\uffff\1\171\7\uffff\1\172",
+ "\1\173",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\23\52\1\174\6\52",
+ "\1\176",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\5\52\1\177\24\52",
+ "\1\u0081",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0083",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0085",
+ "\1\u0086",
+ "\1\u0087",
+ "\1\u0088",
+ "\1\u0089",
+ "\1\u008a",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u008c",
+ "\1\u008d",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\22\52\1\u008e\7\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\15\52\1\u0091\14"+
+ "\52",
+ "",
+ "",
+ "\1\u0093",
+ "",
+ "",
+ "",
+ "\1\u0094",
+ "\1\u0095",
+ "\1\u0096\3\uffff\1\u0097",
+ "\1\u0098",
+ "\1\u0099",
+ "",
+ "\1\u009a",
+ "\1\u009b",
+ "\1\u009c",
+ "\1\u009d",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u009f",
+ "\1\u00a0",
+ "\1\u00a1",
+ "",
+ "",
+ "",
+ "",
+ "\1\u00a2",
+ "\1\u00a3",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00a5",
+ "\1\u00a6",
+ "\1\u00a7",
+ "\1\u00a8",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\1\u00ab",
+ "\1\u00ac",
+ "\1\u00ad",
+ "\1\u00ae",
+ "\1\u00af",
+ "\1\u00b0",
+ "",
+ "\1\u00b1",
+ "\1\u00b2",
+ "\1\u00b3",
+ "",
+ "",
+ "\1\u00b4",
+ "",
+ "\1\u00b5",
+ "\1\u00b6",
+ "\1\u00b7",
+ "\1\u00b8",
+ "\1\u00b9",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\u00bc\1\u00bb\2\u00bc\1\u00ba\25\u00bc\1\uffff\uffdc\u00bc",
+ "\1\u00bd",
+ "\1\u00be",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00c2",
+ "\1\u00c3",
+ "\1\u00c4",
+ "",
+ "\1\u00c5",
+ "\1\u00c6",
+ "\1\u00c7",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "",
+ "\1\u00c8",
+ "\1\u00c9",
+ "\1\u00ca",
+ "\1\u00cb",
+ "\1\u00cc",
+ "\1\u00cd",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00cf",
+ "\1\u00d0",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00d2",
+ "\1\u00d3",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00d5",
+ "\12\u00d6\1\u00d7\ufff5\u00d6",
+ "\0\u00d6",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00d9\uffdc\u00da",
+ "\1\u00db",
+ "\1\u00dc",
+ "",
+ "",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00de",
+ "\1\u00df",
+ "\1\u00e0",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00e5",
+ "\1\u00e6",
+ "\1\u00e7",
+ "",
+ "\1\u00e8",
+ "\1\u00e9",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u00eb",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\0\u00d6",
+ "\12\u00d6\1\u00d7\ufff5\u00d6",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00ed\uffdc\u00da",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00d9\uffdc\u00da",
+ "\1\u00ee",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\1\u00f0",
+ "\1\u00f1",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "",
+ "",
+ "",
+ "\1\u00f2",
+ "\1\u00f3\2\uffff\1\u00f4\1\uffff\1\u00f5\1\u00f6\1\u00f7\1"+
+ "\uffff\1\u00f8\3\uffff\1\u00f9\1\uffff\1\u00fa",
+ "\1\u00fb",
+ "\1\u00fc",
+ "\1\u00fd",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00ff\uffdc\u00da",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0102",
+ "\1\u0103",
+ "",
+ "",
+ "",
+ "\1\u0104",
+ "",
+ "\1\u0105\1\uffff\1\u0106",
+ "",
+ "",
+ "\1\u0107",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0109",
+ "",
+ "\12\u00da\1\u00d7\2\u00da\1\u00d8\25\u00da\1\u00ff\uffdc\u00da",
+ "",
+ "",
+ "\1\u010a",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u010b",
+ "",
+ "",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "",
+ "\1\u010c",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u010d",
+ "\1\u010e",
+ "\1\u010f",
+ "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
+ "\1\u0111",
+ "",
+ "\1\u0112\2\uffff\1\u0113",
+ "",
+ ""
+ };
+
+ static final short[] DFA29_eot = DFA.unpackEncodedString(DFA29_eotS);
+ static final short[] DFA29_eof = DFA.unpackEncodedString(DFA29_eofS);
+ static final char[] DFA29_min = DFA.unpackEncodedStringToUnsignedChars(DFA29_minS);
+ static final char[] DFA29_max = DFA.unpackEncodedStringToUnsignedChars(DFA29_maxS);
+ static final short[] DFA29_accept = DFA.unpackEncodedString(DFA29_acceptS);
+ static final short[] DFA29_special = DFA.unpackEncodedString(DFA29_specialS);
+ static final short[][] DFA29_transition;
+
+ static {
+ int numStates = DFA29_transitionS.length;
+ DFA29_transition = new short[numStates][];
+ for (int i=0; i='\u0000' && LA29_153<='\t')||(LA29_153>='\u000B' && LA29_153<='\f')||(LA29_153>='\u000E' && LA29_153<='\"')||(LA29_153>='$' && LA29_153<='\uFFFF')) ) {s = 188;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA29_186 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_186>='\u0000' && LA29_186<='\t')||(LA29_186>='\u000B' && LA29_186<='\uFFFF')) ) {s = 214;}
+
+ else if ( (LA29_186=='\n') ) {s = 215;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA29_216 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_216>='\u0000' && LA29_216<='\t')||(LA29_216>='\u000B' && LA29_216<='\uFFFF')) ) {s = 214;}
+
+ else if ( (LA29_216=='\n') ) {s = 215;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA29_215 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_215>='\u0000' && LA29_215<='\uFFFF')) ) {s = 214;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA29_218 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_218=='\r') ) {s = 216;}
+
+ else if ( (LA29_218=='\n') ) {s = 215;}
+
+ else if ( (LA29_218=='#') ) {s = 217;}
+
+ else if ( ((LA29_218>='\u0000' && LA29_218<='\t')||(LA29_218>='\u000B' && LA29_218<='\f')||(LA29_218>='\u000E' && LA29_218<='\"')||(LA29_218>='$' && LA29_218<='\uFFFF')) ) {s = 218;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA29_187 = input.LA(1);
+
+ s = -1;
+ if ( ((LA29_187>='\u0000' && LA29_187<='\uFFFF')) ) {s = 214;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA29_255 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_255=='#') ) {s = 255;}
+
+ else if ( (LA29_255=='\r') ) {s = 216;}
+
+ else if ( (LA29_255=='\n') ) {s = 215;}
+
+ else if ( ((LA29_255>='\u0000' && LA29_255<='\t')||(LA29_255>='\u000B' && LA29_255<='\f')||(LA29_255>='\u000E' && LA29_255<='\"')||(LA29_255>='$' && LA29_255<='\uFFFF')) ) {s = 218;}
+
+ else s = 214;
+
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA29_217 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_217=='#') ) {s = 237;}
+
+ else if ( (LA29_217=='\r') ) {s = 216;}
+
+ else if ( (LA29_217=='\n') ) {s = 215;}
+
+ else if ( ((LA29_217>='\u0000' && LA29_217<='\t')||(LA29_217>='\u000B' && LA29_217<='\f')||(LA29_217>='\u000E' && LA29_217<='\"')||(LA29_217>='$' && LA29_217<='\uFFFF')) ) {s = 218;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA29_188 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_188=='\r') ) {s = 216;}
+
+ else if ( (LA29_188=='\n') ) {s = 215;}
+
+ else if ( (LA29_188=='#') ) {s = 217;}
+
+ else if ( ((LA29_188>='\u0000' && LA29_188<='\t')||(LA29_188>='\u000B' && LA29_188<='\f')||(LA29_188>='\u000E' && LA29_188<='\"')||(LA29_188>='$' && LA29_188<='\uFFFF')) ) {s = 218;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA29_237 = input.LA(1);
+
+ s = -1;
+ if ( (LA29_237=='#') ) {s = 255;}
+
+ else if ( (LA29_237=='\r') ) {s = 216;}
+
+ else if ( (LA29_237=='\n') ) {s = 215;}
+
+ else if ( ((LA29_237>='\u0000' && LA29_237<='\t')||(LA29_237>='\u000B' && LA29_237<='\f')||(LA29_237>='\u000E' && LA29_237<='\"')||(LA29_237>='$' && LA29_237<='\uFFFF')) ) {s = 218;}
+
+ else s = 104;
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 29, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefileParser.java b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefileParser.java
new file mode 100644
index 0000000..2142de6
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefileParser.java
@@ -0,0 +1,19071 @@
+package csep.example.cake.parser.antlr.internal;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import csep.example.cake.services.CakefileGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+@SuppressWarnings("all")
+public class InternalCakefileParser extends AbstractInternalAntlrParser {
+ public static final String[] tokenNames = new String[] {
+ "", "", "", "", "RULE_TASK", "RULE_CALL_START", "RULE_COMMA", "RULE_PARAM_START", "RULE_PARAM_END", "RULE_FUNC_ARROW", "RULE_CALL_END", "RULE_TERMINATOR", "RULE_STATEMENT", "RULE_HERECOMMENT", "RULE_EQUAL", "RULE_STRING", "RULE_RETURN", "RULE_POST_IF", "RULE_THROW", "RULE_CLASS", "RULE_EXTENDS", "RULE_FOR", "RULE_WHILE", "RULE_WHEN", "RULE_UNTIL", "RULE_OWN", "RULE_FOROF", "RULE_FORIN", "RULE_BY", "RULE_LBRACKET", "RULE_DOT_DOT", "RULE_ELLIPSIS", "RULE_RBRACKET", "RULE_COMPOUND_ASSIGN", "RULE_INDENT", "RULE_OUTDENT", "RULE_LOGIC", "RULE_COMPARE", "RULE_RELATION", "RULE_SHIFT", "RULE_PLUS", "RULE_MINUS", "RULE_MATH", "RULE_UNARY", "RULE_PLUS_PLUS", "RULE_MINUS_MINUS", "RULE_QUESTION", "RULE_SUPER", "RULE_FUNC_EXIST", "RULE_AT_SIGIL", "RULE_DOT", "RULE_QUESTION_DOT", "RULE_DOUBLE_COLON", "RULE_INDEX_START", "RULE_INDEX_END", "RULE_THIS", "RULE_LOOP", "RULE_TRY", "RULE_CATCH", "RULE_FINALLY", "RULE_SWITCH", "RULE_ELSE", "RULE_LEADING_WHEN", "RULE_IF", "RULE_IDENTIFIER", "RULE_LCURLY", "RULE_RCURLY", "RULE_COLON", "RULE_BOUND_FUNC_ARROW", "RULE_NUMBER", "RULE_BOOL", "RULE_JS", "RULE_REGEX", "RULE_LPAREN", "RULE_RPAREN", "RULE_COLON_SLASH", "RULE_INDEX_PROTO", "RULE_INDEX_SOAK", "RULE_NEW", "RULE_THEN", "RULE_LOGIC_WORD", "RULE_COMPARE_WORD", "RULE_UNARY_WORD", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "'require'"
+ };
+ public static final int RULE_BOUND_FUNC_ARROW=68;
+ public static final int RULE_SWITCH=60;
+ public static final int RULE_THROW=18;
+ public static final int RULE_PARAM_START=7;
+ public static final int RULE_TERMINATOR=11;
+ public static final int RULE_CALL_END=10;
+ public static final int RULE_RETURN=16;
+ public static final int RULE_FOR=21;
+ public static final int RULE_BOOL=70;
+ public static final int RULE_LBRACKET=29;
+ public static final int RULE_DOUBLE_COLON=52;
+ public static final int RULE_MINUS_MINUS=45;
+ public static final int RULE_COMPARE_WORD=81;
+ public static final int EOF=-1;
+ public static final int RULE_OUTDENT=35;
+ public static final int RULE_RELATION=38;
+ public static final int RULE_REGEX=72;
+ public static final int RULE_CLASS=19;
+ public static final int RULE_WHILE=22;
+ public static final int RULE_COLON_SLASH=75;
+ public static final int RULE_FUNC_EXIST=48;
+ public static final int RULE_DOT=50;
+ public static final int RULE_POST_IF=17;
+ public static final int RULE_PLUS_PLUS=44;
+ public static final int RULE_OWN=25;
+ public static final int RULE_NUMBER=69;
+ public static final int RULE_LOOP=56;
+ public static final int RULE_LPAREN=73;
+ public static final int RULE_FUNC_ARROW=9;
+ public static final int RULE_AT_SIGIL=49;
+ public static final int RULE_EXTENDS=20;
+ public static final int RULE_SHIFT=39;
+ public static final int RULE_INDEX_END=54;
+ public static final int RULE_COMPARE=37;
+ public static final int RULE_QUESTION_DOT=51;
+ public static final int RULE_RBRACKET=32;
+ public static final int RULE_COMPOUND_ASSIGN=33;
+ public static final int RULE_SUPER=47;
+ public static final int RULE_THEN=79;
+ public static final int RULE_UNARY_WORD=82;
+ public static final int RULE_LEADING_WHEN=62;
+ public static final int RULE_TASK=4;
+ public static final int RULE_DOT_DOT=30;
+ public static final int RULE_STATEMENT=12;
+ public static final int RULE_PLUS=40;
+ public static final int RULE_BY=28;
+ public static final int RULE_INDEX_SOAK=77;
+ public static final int RULE_CATCH=58;
+ public static final int RULE_CALL_START=5;
+ public static final int RULE_INDEX_PROTO=76;
+ public static final int RULE_IDENTIFIER=64;
+ public static final int RULE_COMMA=6;
+ public static final int RULE_TRY=57;
+ public static final int RULE_JS=71;
+ public static final int RULE_EQUAL=14;
+ public static final int RULE_INDENT=34;
+ public static final int RULE_HERECOMMENT=13;
+ public static final int RULE_FORIN=27;
+ public static final int RULE_ELLIPSIS=31;
+ public static final int RULE_SL_COMMENT=84;
+ public static final int RULE_PARAM_END=8;
+ public static final int T__86=86;
+ public static final int RULE_ML_COMMENT=83;
+ public static final int RULE_WHEN=23;
+ public static final int RULE_INDEX_START=53;
+ public static final int RULE_COLON=67;
+ public static final int RULE_MINUS=41;
+ public static final int RULE_STRING=15;
+ public static final int RULE_NEW=78;
+ public static final int RULE_LOGIC_WORD=80;
+ public static final int RULE_LOGIC=36;
+ public static final int RULE_RPAREN=74;
+ public static final int RULE_WS=85;
+ public static final int RULE_FOROF=26;
+ public static final int RULE_IF=63;
+ public static final int RULE_THIS=55;
+ public static final int RULE_UNARY=43;
+ public static final int RULE_RCURLY=66;
+ public static final int RULE_ELSE=61;
+ public static final int RULE_FINALLY=59;
+ public static final int RULE_MATH=42;
+ public static final int RULE_LCURLY=65;
+ public static final int RULE_QUESTION=46;
+ public static final int RULE_UNTIL=24;
+
+ // delegates
+ // delegators
+
+
+ public InternalCakefileParser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalCakefileParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+
+ }
+
+
+ public String[] getTokenNames() { return InternalCakefileParser.tokenNames; }
+ public String getGrammarFileName() { return "../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g"; }
+
+
+
+ private CakefileGrammarAccess grammarAccess;
+
+ public InternalCakefileParser(TokenStream input, CakefileGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "Cakefile";
+ }
+
+ @Override
+ protected CakefileGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+
+
+
+ // $ANTLR start "entryRuleCakefile"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:67:1: entryRuleCakefile returns [EObject current=null] : iv_ruleCakefile= ruleCakefile EOF ;
+ public final EObject entryRuleCakefile() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleCakefile = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:68:2: (iv_ruleCakefile= ruleCakefile EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:69:2: iv_ruleCakefile= ruleCakefile EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getCakefileRule());
+ }
+ pushFollow(FOLLOW_ruleCakefile_in_entryRuleCakefile75);
+ iv_ruleCakefile=ruleCakefile();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleCakefile;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCakefile85); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleCakefile"
+
+
+ // $ANTLR start "ruleCakefile"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:76:1: ruleCakefile returns [EObject current=null] : ( (lv_tasks_0_0= ruleTaskDeclaration ) )* ;
+ public final EObject ruleCakefile() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_tasks_0_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:79:28: ( ( (lv_tasks_0_0= ruleTaskDeclaration ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:80:1: ( (lv_tasks_0_0= ruleTaskDeclaration ) )*
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:80:1: ( (lv_tasks_0_0= ruleTaskDeclaration ) )*
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0==RULE_TASK) ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:81:1: (lv_tasks_0_0= ruleTaskDeclaration )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:81:1: (lv_tasks_0_0= ruleTaskDeclaration )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:82:3: lv_tasks_0_0= ruleTaskDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCakefileAccess().getTasksTaskDeclarationParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleTaskDeclaration_in_ruleCakefile130);
+ lv_tasks_0_0=ruleTaskDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCakefileRule());
+ }
+ add(
+ current,
+ "tasks",
+ lv_tasks_0_0,
+ "TaskDeclaration");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop1;
+ }
+ } while (true);
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleCakefile"
+
+
+ // $ANTLR start "entryRuleTaskDeclaration"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:106:1: entryRuleTaskDeclaration returns [EObject current=null] : iv_ruleTaskDeclaration= ruleTaskDeclaration EOF ;
+ public final EObject entryRuleTaskDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleTaskDeclaration = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:107:2: (iv_ruleTaskDeclaration= ruleTaskDeclaration EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:108:2: iv_ruleTaskDeclaration= ruleTaskDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getTaskDeclarationRule());
+ }
+ pushFollow(FOLLOW_ruleTaskDeclaration_in_entryRuleTaskDeclaration166);
+ iv_ruleTaskDeclaration=ruleTaskDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleTaskDeclaration;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleTaskDeclaration176); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleTaskDeclaration"
+
+
+ // $ANTLR start "ruleTaskDeclaration"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:115:1: ruleTaskDeclaration returns [EObject current=null] : (this_TASK_0= RULE_TASK this_CALL_START_1= RULE_CALL_START ( (lv_name_2_0= ruleStringLiteral ) ) this_COMMA_3= RULE_COMMA ( (lv_description_4_0= ruleStringLiteral ) ) this_COMMA_5= RULE_COMMA (this_PARAM_START_6= RULE_PARAM_START ( (lv_options_7_0= ruleId ) ) this_PARAM_END_8= RULE_PARAM_END )? this_FUNC_ARROW_9= RULE_FUNC_ARROW ( (lv_body_10_0= ruleBlock ) ) this_CALL_END_11= RULE_CALL_END this_TERMINATOR_12= RULE_TERMINATOR ) ;
+ public final EObject ruleTaskDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ Token this_TASK_0=null;
+ Token this_CALL_START_1=null;
+ Token this_COMMA_3=null;
+ Token this_COMMA_5=null;
+ Token this_PARAM_START_6=null;
+ Token this_PARAM_END_8=null;
+ Token this_FUNC_ARROW_9=null;
+ Token this_CALL_END_11=null;
+ Token this_TERMINATOR_12=null;
+ EObject lv_name_2_0 = null;
+
+ EObject lv_description_4_0 = null;
+
+ EObject lv_options_7_0 = null;
+
+ EObject lv_body_10_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:118:28: ( (this_TASK_0= RULE_TASK this_CALL_START_1= RULE_CALL_START ( (lv_name_2_0= ruleStringLiteral ) ) this_COMMA_3= RULE_COMMA ( (lv_description_4_0= ruleStringLiteral ) ) this_COMMA_5= RULE_COMMA (this_PARAM_START_6= RULE_PARAM_START ( (lv_options_7_0= ruleId ) ) this_PARAM_END_8= RULE_PARAM_END )? this_FUNC_ARROW_9= RULE_FUNC_ARROW ( (lv_body_10_0= ruleBlock ) ) this_CALL_END_11= RULE_CALL_END this_TERMINATOR_12= RULE_TERMINATOR ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:119:1: (this_TASK_0= RULE_TASK this_CALL_START_1= RULE_CALL_START ( (lv_name_2_0= ruleStringLiteral ) ) this_COMMA_3= RULE_COMMA ( (lv_description_4_0= ruleStringLiteral ) ) this_COMMA_5= RULE_COMMA (this_PARAM_START_6= RULE_PARAM_START ( (lv_options_7_0= ruleId ) ) this_PARAM_END_8= RULE_PARAM_END )? this_FUNC_ARROW_9= RULE_FUNC_ARROW ( (lv_body_10_0= ruleBlock ) ) this_CALL_END_11= RULE_CALL_END this_TERMINATOR_12= RULE_TERMINATOR )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:119:1: (this_TASK_0= RULE_TASK this_CALL_START_1= RULE_CALL_START ( (lv_name_2_0= ruleStringLiteral ) ) this_COMMA_3= RULE_COMMA ( (lv_description_4_0= ruleStringLiteral ) ) this_COMMA_5= RULE_COMMA (this_PARAM_START_6= RULE_PARAM_START ( (lv_options_7_0= ruleId ) ) this_PARAM_END_8= RULE_PARAM_END )? this_FUNC_ARROW_9= RULE_FUNC_ARROW ( (lv_body_10_0= ruleBlock ) ) this_CALL_END_11= RULE_CALL_END this_TERMINATOR_12= RULE_TERMINATOR )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:119:2: this_TASK_0= RULE_TASK this_CALL_START_1= RULE_CALL_START ( (lv_name_2_0= ruleStringLiteral ) ) this_COMMA_3= RULE_COMMA ( (lv_description_4_0= ruleStringLiteral ) ) this_COMMA_5= RULE_COMMA (this_PARAM_START_6= RULE_PARAM_START ( (lv_options_7_0= ruleId ) ) this_PARAM_END_8= RULE_PARAM_END )? this_FUNC_ARROW_9= RULE_FUNC_ARROW ( (lv_body_10_0= ruleBlock ) ) this_CALL_END_11= RULE_CALL_END this_TERMINATOR_12= RULE_TERMINATOR
+ {
+ this_TASK_0=(Token)match(input,RULE_TASK,FOLLOW_RULE_TASK_in_ruleTaskDeclaration212); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TASK_0, grammarAccess.getTaskDeclarationAccess().getTASKTerminalRuleCall_0());
+
+ }
+ this_CALL_START_1=(Token)match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_ruleTaskDeclaration222); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_START_1, grammarAccess.getTaskDeclarationAccess().getCALL_STARTTerminalRuleCall_1());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:127:1: ( (lv_name_2_0= ruleStringLiteral ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:128:1: (lv_name_2_0= ruleStringLiteral )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:128:1: (lv_name_2_0= ruleStringLiteral )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:129:3: lv_name_2_0= ruleStringLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getTaskDeclarationAccess().getNameStringLiteralParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_ruleTaskDeclaration242);
+ lv_name_2_0=ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTaskDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_2_0,
+ "StringLiteral");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_COMMA_3=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleTaskDeclaration253); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_3, grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_3());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:149:1: ( (lv_description_4_0= ruleStringLiteral ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:150:1: (lv_description_4_0= ruleStringLiteral )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:150:1: (lv_description_4_0= ruleStringLiteral )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:151:3: lv_description_4_0= ruleStringLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getTaskDeclarationAccess().getDescriptionStringLiteralParserRuleCall_4_0());
+
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_ruleTaskDeclaration273);
+ lv_description_4_0=ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTaskDeclarationRule());
+ }
+ set(
+ current,
+ "description",
+ lv_description_4_0,
+ "StringLiteral");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_COMMA_5=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleTaskDeclaration284); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_5, grammarAccess.getTaskDeclarationAccess().getCOMMATerminalRuleCall_5());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:171:1: (this_PARAM_START_6= RULE_PARAM_START ( (lv_options_7_0= ruleId ) ) this_PARAM_END_8= RULE_PARAM_END )?
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0==RULE_PARAM_START) ) {
+ alt2=1;
+ }
+ switch (alt2) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:171:2: this_PARAM_START_6= RULE_PARAM_START ( (lv_options_7_0= ruleId ) ) this_PARAM_END_8= RULE_PARAM_END
+ {
+ this_PARAM_START_6=(Token)match(input,RULE_PARAM_START,FOLLOW_RULE_PARAM_START_in_ruleTaskDeclaration295); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PARAM_START_6, grammarAccess.getTaskDeclarationAccess().getPARAM_STARTTerminalRuleCall_6_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:175:1: ( (lv_options_7_0= ruleId ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:176:1: (lv_options_7_0= ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:176:1: (lv_options_7_0= ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:177:3: lv_options_7_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getTaskDeclarationAccess().getOptionsIdParserRuleCall_6_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleTaskDeclaration315);
+ lv_options_7_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTaskDeclarationRule());
+ }
+ set(
+ current,
+ "options",
+ lv_options_7_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_PARAM_END_8=(Token)match(input,RULE_PARAM_END,FOLLOW_RULE_PARAM_END_in_ruleTaskDeclaration326); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PARAM_END_8, grammarAccess.getTaskDeclarationAccess().getPARAM_ENDTerminalRuleCall_6_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+ this_FUNC_ARROW_9=(Token)match(input,RULE_FUNC_ARROW,FOLLOW_RULE_FUNC_ARROW_in_ruleTaskDeclaration338); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FUNC_ARROW_9, grammarAccess.getTaskDeclarationAccess().getFUNC_ARROWTerminalRuleCall_7());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:201:1: ( (lv_body_10_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:202:1: (lv_body_10_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:202:1: (lv_body_10_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:203:3: lv_body_10_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getTaskDeclarationAccess().getBodyBlockParserRuleCall_8_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleTaskDeclaration358);
+ lv_body_10_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTaskDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_10_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_CALL_END_11=(Token)match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_ruleTaskDeclaration369); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_END_11, grammarAccess.getTaskDeclarationAccess().getCALL_ENDTerminalRuleCall_9());
+
+ }
+ this_TERMINATOR_12=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleTaskDeclaration379); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_12, grammarAccess.getTaskDeclarationAccess().getTERMINATORTerminalRuleCall_10());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleTaskDeclaration"
+
+
+ // $ANTLR start "entryRuleBody"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:237:1: entryRuleBody returns [EObject current=null] : iv_ruleBody= ruleBody EOF ;
+ public final EObject entryRuleBody() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleBody = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:238:2: (iv_ruleBody= ruleBody EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:239:2: iv_ruleBody= ruleBody EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getBodyRule());
+ }
+ pushFollow(FOLLOW_ruleBody_in_entryRuleBody416);
+ iv_ruleBody=ruleBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleBody;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBody426); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleBody"
+
+
+ // $ANTLR start "ruleBody"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:246:1: ruleBody returns [EObject current=null] : ( ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )* ) ;
+ public final EObject ruleBody() throws RecognitionException {
+ EObject current = null;
+
+ Token this_TERMINATOR_1=null;
+ EObject lv_lines_0_0 = null;
+
+ EObject lv_lines_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:249:28: ( ( ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:250:1: ( ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:250:1: ( ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:250:2: ( (lv_lines_0_0= ruleLine ) ) (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )*
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:250:2: ( (lv_lines_0_0= ruleLine ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:251:1: (lv_lines_0_0= ruleLine )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:251:1: (lv_lines_0_0= ruleLine )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:252:3: lv_lines_0_0= ruleLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleLine_in_ruleBody472);
+ lv_lines_0_0=ruleLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getBodyRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_0_0,
+ "Line");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:268:2: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )? )*
+ loop4:
+ do {
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0==RULE_TERMINATOR) ) {
+ alt4=1;
+ }
+
+
+ switch (alt4) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:268:3: this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleLine ) )?
+ {
+ this_TERMINATOR_1=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleBody484); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getBodyAccess().getTERMINATORTerminalRuleCall_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:272:1: ( (lv_lines_2_0= ruleLine ) )?
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0==RULE_PARAM_START||LA3_0==RULE_FUNC_ARROW||(LA3_0>=RULE_STATEMENT && LA3_0<=RULE_HERECOMMENT)||(LA3_0>=RULE_STRING && LA3_0<=RULE_RETURN)||(LA3_0>=RULE_THROW && LA3_0<=RULE_CLASS)||(LA3_0>=RULE_FOR && LA3_0<=RULE_WHILE)||LA3_0==RULE_UNTIL||LA3_0==RULE_LBRACKET||(LA3_0>=RULE_PLUS && LA3_0<=RULE_MINUS)||(LA3_0>=RULE_UNARY && LA3_0<=RULE_MINUS_MINUS)||LA3_0==RULE_SUPER||LA3_0==RULE_AT_SIGIL||(LA3_0>=RULE_THIS && LA3_0<=RULE_TRY)||LA3_0==RULE_SWITCH||(LA3_0>=RULE_IF && LA3_0<=RULE_LCURLY)||(LA3_0>=RULE_BOUND_FUNC_ARROW && LA3_0<=RULE_LPAREN)) ) {
+ alt3=1;
+ }
+ switch (alt3) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:273:1: (lv_lines_2_0= ruleLine )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:273:1: (lv_lines_2_0= ruleLine )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:274:3: lv_lines_2_0= ruleLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getBodyAccess().getLinesLineParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleLine_in_ruleBody504);
+ lv_lines_2_0=ruleLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getBodyRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_2_0,
+ "Line");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop4;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleBody"
+
+
+ // $ANTLR start "entryRuleLine"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:298:1: entryRuleLine returns [EObject current=null] : iv_ruleLine= ruleLine EOF ;
+ public final EObject entryRuleLine() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleLine = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:299:2: (iv_ruleLine= ruleLine EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:300:2: iv_ruleLine= ruleLine EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getLineRule());
+ }
+ pushFollow(FOLLOW_ruleLine_in_entryRuleLine543);
+ iv_ruleLine=ruleLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleLine;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLine553); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleLine"
+
+
+ // $ANTLR start "ruleLine"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:307:1: ruleLine returns [EObject current=null] : (this_Stmt_0= ruleStmt | this_Expression_1= ruleExpression ) ;
+ public final EObject ruleLine() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Stmt_0 = null;
+
+ EObject this_Expression_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:310:28: ( (this_Stmt_0= ruleStmt | this_Expression_1= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:311:1: (this_Stmt_0= ruleStmt | this_Expression_1= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:311:1: (this_Stmt_0= ruleStmt | this_Expression_1= ruleExpression )
+ int alt5=2;
+ switch ( input.LA(1) ) {
+ case RULE_STATEMENT:
+ case RULE_HERECOMMENT:
+ case RULE_RETURN:
+ case RULE_THROW:
+ case RULE_CLASS:
+ {
+ alt5=1;
+ }
+ break;
+ case RULE_IDENTIFIER:
+ {
+ int LA5_2 = input.LA(2);
+
+ if ( (LA5_2==EOF||LA5_2==RULE_CALL_START||LA5_2==RULE_TERMINATOR||LA5_2==RULE_POST_IF||(LA5_2>=RULE_FOR && LA5_2<=RULE_WHILE)||LA5_2==RULE_UNTIL||LA5_2==RULE_COMPOUND_ASSIGN||(LA5_2>=RULE_OUTDENT && LA5_2<=RULE_MATH)||LA5_2==RULE_QUESTION||LA5_2==RULE_FUNC_EXIST||(LA5_2>=RULE_DOT && LA5_2<=RULE_INDEX_START)||LA5_2==RULE_RPAREN) ) {
+ alt5=2;
+ }
+ else if ( (LA5_2==RULE_EQUAL) ) {
+ int LA5_4 = input.LA(3);
+
+ if ( (LA5_4==86) ) {
+ alt5=1;
+ }
+ else if ( (LA5_4==RULE_PARAM_START||LA5_4==RULE_FUNC_ARROW||LA5_4==RULE_STRING||LA5_4==RULE_CLASS||(LA5_4>=RULE_FOR && LA5_4<=RULE_WHILE)||LA5_4==RULE_UNTIL||LA5_4==RULE_LBRACKET||LA5_4==RULE_INDENT||(LA5_4>=RULE_PLUS && LA5_4<=RULE_MINUS)||(LA5_4>=RULE_UNARY && LA5_4<=RULE_MINUS_MINUS)||LA5_4==RULE_SUPER||LA5_4==RULE_AT_SIGIL||(LA5_4>=RULE_THIS && LA5_4<=RULE_TRY)||LA5_4==RULE_SWITCH||(LA5_4>=RULE_IF && LA5_4<=RULE_LCURLY)||(LA5_4>=RULE_BOUND_FUNC_ARROW && LA5_4<=RULE_LPAREN)) ) {
+ alt5=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 5, 4, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 5, 2, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case RULE_PARAM_START:
+ case RULE_FUNC_ARROW:
+ case RULE_STRING:
+ case RULE_FOR:
+ case RULE_WHILE:
+ case RULE_UNTIL:
+ case RULE_LBRACKET:
+ case RULE_PLUS:
+ case RULE_MINUS:
+ case RULE_UNARY:
+ case RULE_PLUS_PLUS:
+ case RULE_MINUS_MINUS:
+ case RULE_SUPER:
+ case RULE_AT_SIGIL:
+ case RULE_THIS:
+ case RULE_LOOP:
+ case RULE_TRY:
+ case RULE_SWITCH:
+ case RULE_IF:
+ case RULE_LCURLY:
+ case RULE_BOUND_FUNC_ARROW:
+ case RULE_NUMBER:
+ case RULE_BOOL:
+ case RULE_JS:
+ case RULE_REGEX:
+ case RULE_LPAREN:
+ {
+ alt5=2;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 5, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt5) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:312:5: this_Stmt_0= ruleStmt
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLineAccess().getStmtParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleStmt_in_ruleLine600);
+ this_Stmt_0=ruleStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Stmt_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:322:5: this_Expression_1= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLineAccess().getExpressionParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleLine627);
+ this_Expression_1=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Expression_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleLine"
+
+
+ // $ANTLR start "entryRuleStmt"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:338:1: entryRuleStmt returns [EObject current=null] : iv_ruleStmt= ruleStmt EOF ;
+ public final EObject entryRuleStmt() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleStmt = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:339:2: (iv_ruleStmt= ruleStmt EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:340:2: iv_ruleStmt= ruleStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getStmtRule());
+ }
+ pushFollow(FOLLOW_ruleStmt_in_entryRuleStmt662);
+ iv_ruleStmt=ruleStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleStmt;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleStmt672); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleStmt"
+
+
+ // $ANTLR start "ruleStmt"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:347:1: ruleStmt returns [EObject current=null] : (this_ReturnStmt_0= ruleReturnStmt | this_ThrowStmt_1= ruleThrowStmt | ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt ) | this_Comment_3= ruleComment | this_ClassDeclaration_4= ruleClassDeclaration | ( (lv_statement_5_0= RULE_STATEMENT ) ) ) ;
+ public final EObject ruleStmt() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_statement_5_0=null;
+ EObject this_ReturnStmt_0 = null;
+
+ EObject this_ThrowStmt_1 = null;
+
+ EObject this_RequireStmt_2 = null;
+
+ EObject this_Comment_3 = null;
+
+ EObject this_ClassDeclaration_4 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:350:28: ( (this_ReturnStmt_0= ruleReturnStmt | this_ThrowStmt_1= ruleThrowStmt | ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt ) | this_Comment_3= ruleComment | this_ClassDeclaration_4= ruleClassDeclaration | ( (lv_statement_5_0= RULE_STATEMENT ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:351:1: (this_ReturnStmt_0= ruleReturnStmt | this_ThrowStmt_1= ruleThrowStmt | ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt ) | this_Comment_3= ruleComment | this_ClassDeclaration_4= ruleClassDeclaration | ( (lv_statement_5_0= RULE_STATEMENT ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:351:1: (this_ReturnStmt_0= ruleReturnStmt | this_ThrowStmt_1= ruleThrowStmt | ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt ) | this_Comment_3= ruleComment | this_ClassDeclaration_4= ruleClassDeclaration | ( (lv_statement_5_0= RULE_STATEMENT ) ) )
+ int alt6=6;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0==RULE_RETURN) ) {
+ alt6=1;
+ }
+ else if ( (LA6_0==RULE_THROW) ) {
+ alt6=2;
+ }
+ else if ( (LA6_0==RULE_IDENTIFIER) && (synpred1_InternalCakefile())) {
+ alt6=3;
+ }
+ else if ( (LA6_0==RULE_HERECOMMENT) ) {
+ alt6=4;
+ }
+ else if ( (LA6_0==RULE_CLASS) ) {
+ alt6=5;
+ }
+ else if ( (LA6_0==RULE_STATEMENT) ) {
+ alt6=6;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 6, 0, input);
+
+ throw nvae;
+ }
+ switch (alt6) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:352:5: this_ReturnStmt_0= ruleReturnStmt
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getReturnStmtParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleReturnStmt_in_ruleStmt719);
+ this_ReturnStmt_0=ruleReturnStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ReturnStmt_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:362:5: this_ThrowStmt_1= ruleThrowStmt
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getThrowStmtParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleThrowStmt_in_ruleStmt746);
+ this_ThrowStmt_1=ruleThrowStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ThrowStmt_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:371:6: ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:371:6: ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:371:7: ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=>this_RequireStmt_2= ruleRequireStmt
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getRequireStmtParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleRequireStmt_in_ruleStmt794);
+ this_RequireStmt_2=ruleRequireStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_RequireStmt_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:387:5: this_Comment_3= ruleComment
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getCommentParserRuleCall_3());
+
+ }
+ pushFollow(FOLLOW_ruleComment_in_ruleStmt822);
+ this_Comment_3=ruleComment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Comment_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:397:5: this_ClassDeclaration_4= ruleClassDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getStmtAccess().getClassDeclarationParserRuleCall_4());
+
+ }
+ pushFollow(FOLLOW_ruleClassDeclaration_in_ruleStmt849);
+ this_ClassDeclaration_4=ruleClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ClassDeclaration_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:406:6: ( (lv_statement_5_0= RULE_STATEMENT ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:406:6: ( (lv_statement_5_0= RULE_STATEMENT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:407:1: (lv_statement_5_0= RULE_STATEMENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:407:1: (lv_statement_5_0= RULE_STATEMENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:408:3: lv_statement_5_0= RULE_STATEMENT
+ {
+ lv_statement_5_0=(Token)match(input,RULE_STATEMENT,FOLLOW_RULE_STATEMENT_in_ruleStmt871); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_statement_5_0, grammarAccess.getStmtAccess().getStatementSTATEMENTTerminalRuleCall_5_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getStmtRule());
+ }
+ setWithLastConsumed(
+ current,
+ "statement",
+ lv_statement_5_0,
+ "STATEMENT");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleStmt"
+
+
+ // $ANTLR start "entryRuleComment"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:432:1: entryRuleComment returns [EObject current=null] : iv_ruleComment= ruleComment EOF ;
+ public final EObject entryRuleComment() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleComment = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:433:2: (iv_ruleComment= ruleComment EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:434:2: iv_ruleComment= ruleComment EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getCommentRule());
+ }
+ pushFollow(FOLLOW_ruleComment_in_entryRuleComment912);
+ iv_ruleComment=ruleComment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleComment;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleComment922); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleComment"
+
+
+ // $ANTLR start "ruleComment"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:441:1: ruleComment returns [EObject current=null] : ( (lv_comment_0_0= RULE_HERECOMMENT ) ) ;
+ public final EObject ruleComment() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_comment_0_0=null;
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:444:28: ( ( (lv_comment_0_0= RULE_HERECOMMENT ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:445:1: ( (lv_comment_0_0= RULE_HERECOMMENT ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:445:1: ( (lv_comment_0_0= RULE_HERECOMMENT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:446:1: (lv_comment_0_0= RULE_HERECOMMENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:446:1: (lv_comment_0_0= RULE_HERECOMMENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:447:3: lv_comment_0_0= RULE_HERECOMMENT
+ {
+ lv_comment_0_0=(Token)match(input,RULE_HERECOMMENT,FOLLOW_RULE_HERECOMMENT_in_ruleComment963); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_comment_0_0, grammarAccess.getCommentAccess().getCommentHERECOMMENTTerminalRuleCall_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getCommentRule());
+ }
+ setWithLastConsumed(
+ current,
+ "comment",
+ lv_comment_0_0,
+ "HERECOMMENT");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleComment"
+
+
+ // $ANTLR start "entryRuleRequireStmt"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:471:1: entryRuleRequireStmt returns [EObject current=null] : iv_ruleRequireStmt= ruleRequireStmt EOF ;
+ public final EObject entryRuleRequireStmt() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRequireStmt = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:472:2: (iv_ruleRequireStmt= ruleRequireStmt EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:473:2: iv_ruleRequireStmt= ruleRequireStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getRequireStmtRule());
+ }
+ pushFollow(FOLLOW_ruleRequireStmt_in_entryRuleRequireStmt1003);
+ iv_ruleRequireStmt=ruleRequireStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleRequireStmt;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRequireStmt1013); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRequireStmt"
+
+
+ // $ANTLR start "ruleRequireStmt"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:480:1: ruleRequireStmt returns [EObject current=null] : ( ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END ) ;
+ public final EObject ruleRequireStmt() throws RecognitionException {
+ EObject current = null;
+
+ Token this_EQUAL_1=null;
+ Token otherlv_2=null;
+ Token this_CALL_START_3=null;
+ Token lv_uri_4_0=null;
+ Token this_CALL_END_5=null;
+ EObject lv_importedNamespace_0_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:483:28: ( ( ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:484:1: ( ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:484:1: ( ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:484:2: ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) ) this_CALL_START_3= RULE_CALL_START ( (lv_uri_4_0= RULE_STRING ) ) this_CALL_END_5= RULE_CALL_END
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:484:2: ( ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:484:3: ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )=> ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:489:5: ( ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:489:6: ( (lv_importedNamespace_0_0= ruleId ) ) this_EQUAL_1= RULE_EQUAL otherlv_2= 'require'
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:489:6: ( (lv_importedNamespace_0_0= ruleId ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:490:1: (lv_importedNamespace_0_0= ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:490:1: (lv_importedNamespace_0_0= ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:491:3: lv_importedNamespace_0_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRequireStmtAccess().getImportedNamespaceIdParserRuleCall_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleRequireStmt1081);
+ lv_importedNamespace_0_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRequireStmtRule());
+ }
+ set(
+ current,
+ "importedNamespace",
+ lv_importedNamespace_0_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_EQUAL_1=(Token)match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_ruleRequireStmt1092); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EQUAL_1, grammarAccess.getRequireStmtAccess().getEQUALTerminalRuleCall_0_0_1());
+
+ }
+ otherlv_2=(Token)match(input,86,FOLLOW_86_in_ruleRequireStmt1103); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_2, grammarAccess.getRequireStmtAccess().getRequireKeyword_0_0_2());
+
+ }
+
+ }
+
+
+ }
+
+ this_CALL_START_3=(Token)match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_ruleRequireStmt1116); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_START_3, grammarAccess.getRequireStmtAccess().getCALL_STARTTerminalRuleCall_1());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:519:1: ( (lv_uri_4_0= RULE_STRING ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:520:1: (lv_uri_4_0= RULE_STRING )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:520:1: (lv_uri_4_0= RULE_STRING )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:521:3: lv_uri_4_0= RULE_STRING
+ {
+ lv_uri_4_0=(Token)match(input,RULE_STRING,FOLLOW_RULE_STRING_in_ruleRequireStmt1132); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_uri_4_0, grammarAccess.getRequireStmtAccess().getUriSTRINGTerminalRuleCall_2_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRequireStmtRule());
+ }
+ setWithLastConsumed(
+ current,
+ "uri",
+ lv_uri_4_0,
+ "STRING");
+
+ }
+
+ }
+
+
+ }
+
+ this_CALL_END_5=(Token)match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_ruleRequireStmt1148); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_END_5, grammarAccess.getRequireStmtAccess().getCALL_ENDTerminalRuleCall_3());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRequireStmt"
+
+
+ // $ANTLR start "entryRuleReturnStmt"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:549:1: entryRuleReturnStmt returns [EObject current=null] : iv_ruleReturnStmt= ruleReturnStmt EOF ;
+ public final EObject entryRuleReturnStmt() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleReturnStmt = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:550:2: (iv_ruleReturnStmt= ruleReturnStmt EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:551:2: iv_ruleReturnStmt= ruleReturnStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getReturnStmtRule());
+ }
+ pushFollow(FOLLOW_ruleReturnStmt_in_entryRuleReturnStmt1183);
+ iv_ruleReturnStmt=ruleReturnStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleReturnStmt;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleReturnStmt1193); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleReturnStmt"
+
+
+ // $ANTLR start "ruleReturnStmt"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:558:1: ruleReturnStmt returns [EObject current=null] : ( () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )? ) ;
+ public final EObject ruleReturnStmt() throws RecognitionException {
+ EObject current = null;
+
+ Token this_RETURN_1=null;
+ Token this_POST_IF_3=null;
+ EObject lv_expression_2_0 = null;
+
+ EObject lv_condition_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:561:28: ( ( () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:562:1: ( () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:562:1: ( () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:562:2: () this_RETURN_1= RULE_RETURN ( (lv_expression_2_0= ruleExpression ) )? (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:562:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:563:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getReturnStmtAccess().getReturnStmtAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_RETURN_1=(Token)match(input,RULE_RETURN,FOLLOW_RULE_RETURN_in_ruleReturnStmt1238); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RETURN_1, grammarAccess.getReturnStmtAccess().getRETURNTerminalRuleCall_1());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:572:1: ( (lv_expression_2_0= ruleExpression ) )?
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0==RULE_PARAM_START||LA7_0==RULE_FUNC_ARROW||LA7_0==RULE_STRING||(LA7_0>=RULE_FOR && LA7_0<=RULE_WHILE)||LA7_0==RULE_UNTIL||LA7_0==RULE_LBRACKET||(LA7_0>=RULE_PLUS && LA7_0<=RULE_MINUS)||(LA7_0>=RULE_UNARY && LA7_0<=RULE_MINUS_MINUS)||LA7_0==RULE_SUPER||LA7_0==RULE_AT_SIGIL||(LA7_0>=RULE_THIS && LA7_0<=RULE_TRY)||LA7_0==RULE_SWITCH||(LA7_0>=RULE_IF && LA7_0<=RULE_LCURLY)||(LA7_0>=RULE_BOUND_FUNC_ARROW && LA7_0<=RULE_LPAREN)) ) {
+ alt7=1;
+ }
+ switch (alt7) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:573:1: (lv_expression_2_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:573:1: (lv_expression_2_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:574:3: lv_expression_2_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getReturnStmtAccess().getExpressionExpressionParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleReturnStmt1258);
+ lv_expression_2_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getReturnStmtRule());
+ }
+ set(
+ current,
+ "expression",
+ lv_expression_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:590:3: (this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) ) )?
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0==RULE_POST_IF) ) {
+ alt8=1;
+ }
+ switch (alt8) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:590:4: this_POST_IF_3= RULE_POST_IF ( (lv_condition_4_0= ruleExpression ) )
+ {
+ this_POST_IF_3=(Token)match(input,RULE_POST_IF,FOLLOW_RULE_POST_IF_in_ruleReturnStmt1271); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_POST_IF_3, grammarAccess.getReturnStmtAccess().getPOST_IFTerminalRuleCall_3_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:594:1: ( (lv_condition_4_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:595:1: (lv_condition_4_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:595:1: (lv_condition_4_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:596:3: lv_condition_4_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getReturnStmtAccess().getConditionExpressionParserRuleCall_3_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleReturnStmt1291);
+ lv_condition_4_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getReturnStmtRule());
+ }
+ set(
+ current,
+ "condition",
+ lv_condition_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleReturnStmt"
+
+
+ // $ANTLR start "entryRuleThrowStmt"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:620:1: entryRuleThrowStmt returns [EObject current=null] : iv_ruleThrowStmt= ruleThrowStmt EOF ;
+ public final EObject entryRuleThrowStmt() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleThrowStmt = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:621:2: (iv_ruleThrowStmt= ruleThrowStmt EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:622:2: iv_ruleThrowStmt= ruleThrowStmt EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getThrowStmtRule());
+ }
+ pushFollow(FOLLOW_ruleThrowStmt_in_entryRuleThrowStmt1329);
+ iv_ruleThrowStmt=ruleThrowStmt();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleThrowStmt;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleThrowStmt1339); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleThrowStmt"
+
+
+ // $ANTLR start "ruleThrowStmt"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:629:1: ruleThrowStmt returns [EObject current=null] : (this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) ) ) ;
+ public final EObject ruleThrowStmt() throws RecognitionException {
+ EObject current = null;
+
+ Token this_THROW_0=null;
+ EObject lv_exp_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:632:28: ( (this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:633:1: (this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:633:1: (this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:633:2: this_THROW_0= RULE_THROW ( (lv_exp_1_0= ruleExpression ) )
+ {
+ this_THROW_0=(Token)match(input,RULE_THROW,FOLLOW_RULE_THROW_in_ruleThrowStmt1375); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_THROW_0, grammarAccess.getThrowStmtAccess().getTHROWTerminalRuleCall_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:637:1: ( (lv_exp_1_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:638:1: (lv_exp_1_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:638:1: (lv_exp_1_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:639:3: lv_exp_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getThrowStmtAccess().getExpExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleThrowStmt1395);
+ lv_exp_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getThrowStmtRule());
+ }
+ set(
+ current,
+ "exp",
+ lv_exp_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleThrowStmt"
+
+
+ // $ANTLR start "entryRuleSuperClass"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:663:1: entryRuleSuperClass returns [EObject current=null] : iv_ruleSuperClass= ruleSuperClass EOF ;
+ public final EObject entryRuleSuperClass() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleSuperClass = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:664:2: (iv_ruleSuperClass= ruleSuperClass EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:665:2: iv_ruleSuperClass= ruleSuperClass EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getSuperClassRule());
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_entryRuleSuperClass1431);
+ iv_ruleSuperClass=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleSuperClass;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleSuperClass1441); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleSuperClass"
+
+
+ // $ANTLR start "ruleSuperClass"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:672:1: ruleSuperClass returns [EObject current=null] : (this_IdRef_0= ruleIdRef | this_Property_1= ruleProperty ) ;
+ public final EObject ruleSuperClass() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_IdRef_0 = null;
+
+ EObject this_Property_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:675:28: ( (this_IdRef_0= ruleIdRef | this_Property_1= ruleProperty ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:676:1: (this_IdRef_0= ruleIdRef | this_Property_1= ruleProperty )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:676:1: (this_IdRef_0= ruleIdRef | this_Property_1= ruleProperty )
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0==RULE_IDENTIFIER) ) {
+ int LA9_1 = input.LA(2);
+
+ if ( ((LA9_1>=RULE_DOT && LA9_1<=RULE_INDEX_START)) ) {
+ alt9=2;
+ }
+ else if ( (LA9_1==EOF||LA9_1==RULE_TERMINATOR||(LA9_1>=RULE_INDENT && LA9_1<=RULE_OUTDENT)||LA9_1==RULE_RPAREN) ) {
+ alt9=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 9, 0, input);
+
+ throw nvae;
+ }
+ switch (alt9) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:677:5: this_IdRef_0= ruleIdRef
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getSuperClassAccess().getIdRefParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_ruleSuperClass1488);
+ this_IdRef_0=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IdRef_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:687:5: this_Property_1= ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getSuperClassAccess().getPropertyParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleProperty_in_ruleSuperClass1515);
+ this_Property_1=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Property_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleSuperClass"
+
+
+ // $ANTLR start "entryRuleClassDeclaration"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:703:1: entryRuleClassDeclaration returns [EObject current=null] : iv_ruleClassDeclaration= ruleClassDeclaration EOF ;
+ public final EObject entryRuleClassDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleClassDeclaration = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:704:2: (iv_ruleClassDeclaration= ruleClassDeclaration EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:705:2: iv_ruleClassDeclaration= ruleClassDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getClassDeclarationRule());
+ }
+ pushFollow(FOLLOW_ruleClassDeclaration_in_entryRuleClassDeclaration1550);
+ iv_ruleClassDeclaration=ruleClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleClassDeclaration;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleClassDeclaration1560); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleClassDeclaration"
+
+
+ // $ANTLR start "ruleClassDeclaration"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:712:1: ruleClassDeclaration returns [EObject current=null] : ( () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )? ) ;
+ public final EObject ruleClassDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ Token this_CLASS_1=null;
+ Token this_EXTENDS_3=null;
+ Token this_EXTENDS_7=null;
+ EObject lv_body_2_0 = null;
+
+ EObject lv_extend_4_0 = null;
+
+ EObject lv_body_5_0 = null;
+
+ EObject lv_name_6_1 = null;
+
+ EObject lv_name_6_2 = null;
+
+ EObject lv_extend_8_0 = null;
+
+ EObject lv_body_9_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:715:28: ( ( () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:716:1: ( () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:716:1: ( () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:716:2: () this_CLASS_1= RULE_CLASS ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:716:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:717:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getClassDeclarationAccess().getClassDeclarationAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_CLASS_1=(Token)match(input,RULE_CLASS,FOLLOW_RULE_CLASS_in_ruleClassDeclaration1605); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CLASS_1, grammarAccess.getClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:726:1: ( ( (lv_body_2_0= ruleBlock ) ) | (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? ) | ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) ) )?
+ int alt13=4;
+ switch ( input.LA(1) ) {
+ case RULE_INDENT:
+ {
+ alt13=1;
+ }
+ break;
+ case RULE_EXTENDS:
+ {
+ alt13=2;
+ }
+ break;
+ case RULE_IDENTIFIER:
+ {
+ alt13=3;
+ }
+ break;
+ }
+
+ switch (alt13) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:726:2: ( (lv_body_2_0= ruleBlock ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:726:2: ( (lv_body_2_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:727:1: (lv_body_2_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:727:1: (lv_body_2_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:728:3: lv_body_2_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleClassDeclaration1626);
+ lv_body_2_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:745:6: (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:745:6: (this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:745:7: this_EXTENDS_3= RULE_EXTENDS ( (lv_extend_4_0= ruleSuperClass ) ) ( (lv_body_5_0= ruleBlock ) )?
+ {
+ this_EXTENDS_3=(Token)match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_ruleClassDeclaration1644); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EXTENDS_3, grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:749:1: ( (lv_extend_4_0= ruleSuperClass ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:750:1: (lv_extend_4_0= ruleSuperClass )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:750:1: (lv_extend_4_0= ruleSuperClass )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:751:3: lv_extend_4_0= ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_ruleClassDeclaration1664);
+ lv_extend_4_0=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "extend",
+ lv_extend_4_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:767:2: ( (lv_body_5_0= ruleBlock ) )?
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0==RULE_INDENT) ) {
+ alt10=1;
+ }
+ switch (alt10) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:768:1: (lv_body_5_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:768:1: (lv_body_5_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:769:3: lv_body_5_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleClassDeclaration1685);
+ lv_body_5_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_5_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:786:6: ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:786:6: ( ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:786:7: ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) ) (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )? ( (lv_body_9_0= ruleBlock ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:786:7: ( ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:787:1: ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:787:1: ( (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:788:1: (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:788:1: (lv_name_6_1= ruleId | lv_name_6_2= ruleProperty )
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0==RULE_IDENTIFIER) ) {
+ int LA11_1 = input.LA(2);
+
+ if ( ((LA11_1>=RULE_DOT && LA11_1<=RULE_INDEX_START)) ) {
+ alt11=2;
+ }
+ else if ( (LA11_1==RULE_EXTENDS||LA11_1==RULE_INDENT) ) {
+ alt11=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 0, input);
+
+ throw nvae;
+ }
+ switch (alt11) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:789:3: lv_name_6_1= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getNameIdParserRuleCall_2_2_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleClassDeclaration1717);
+ lv_name_6_1=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_6_1,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:804:8: lv_name_6_2= ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getNamePropertyParserRuleCall_2_2_0_0_1());
+
+ }
+ pushFollow(FOLLOW_ruleProperty_in_ruleClassDeclaration1736);
+ lv_name_6_2=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_6_2,
+ "Property");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:822:2: (this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) ) )?
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0==RULE_EXTENDS) ) {
+ alt12=1;
+ }
+ switch (alt12) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:822:3: this_EXTENDS_7= RULE_EXTENDS ( (lv_extend_8_0= ruleSuperClass ) )
+ {
+ this_EXTENDS_7=(Token)match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_ruleClassDeclaration1751); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EXTENDS_7, grammarAccess.getClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_2_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:826:1: ( (lv_extend_8_0= ruleSuperClass ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:827:1: (lv_extend_8_0= ruleSuperClass )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:827:1: (lv_extend_8_0= ruleSuperClass )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:828:3: lv_extend_8_0= ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_ruleClassDeclaration1771);
+ lv_extend_8_0=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "extend",
+ lv_extend_8_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:844:4: ( (lv_body_9_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:845:1: (lv_body_9_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:845:1: (lv_body_9_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:846:3: lv_body_9_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getClassDeclarationAccess().getBodyBlockParserRuleCall_2_2_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleClassDeclaration1794);
+ lv_body_9_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_9_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleClassDeclaration"
+
+
+ // $ANTLR start "entryRuleAssignedClassDeclaration"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:870:1: entryRuleAssignedClassDeclaration returns [EObject current=null] : iv_ruleAssignedClassDeclaration= ruleAssignedClassDeclaration EOF ;
+ public final EObject entryRuleAssignedClassDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignedClassDeclaration = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:871:2: (iv_ruleAssignedClassDeclaration= ruleAssignedClassDeclaration EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:872:2: iv_ruleAssignedClassDeclaration= ruleAssignedClassDeclaration EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ pushFollow(FOLLOW_ruleAssignedClassDeclaration_in_entryRuleAssignedClassDeclaration1833);
+ iv_ruleAssignedClassDeclaration=ruleAssignedClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignedClassDeclaration;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignedClassDeclaration1843); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignedClassDeclaration"
+
+
+ // $ANTLR start "ruleAssignedClassDeclaration"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:879:1: ruleAssignedClassDeclaration returns [EObject current=null] : ( () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )? ) ;
+ public final EObject ruleAssignedClassDeclaration() throws RecognitionException {
+ EObject current = null;
+
+ Token this_CLASS_1=null;
+ Token this_EXTENDS_2=null;
+ Token this_EXTENDS_6=null;
+ EObject lv_extend_3_0 = null;
+
+ EObject lv_body_4_0 = null;
+
+ EObject lv_name_5_1 = null;
+
+ EObject lv_name_5_2 = null;
+
+ EObject lv_extend_7_0 = null;
+
+ EObject lv_body_8_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:882:28: ( ( () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:883:1: ( () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:883:1: ( () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:883:2: () this_CLASS_1= RULE_CLASS ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:883:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:884:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getAssignedClassDeclarationAccess().getClassDeclarationAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_CLASS_1=(Token)match(input,RULE_CLASS,FOLLOW_RULE_CLASS_in_ruleAssignedClassDeclaration1888); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CLASS_1, grammarAccess.getAssignedClassDeclarationAccess().getCLASSTerminalRuleCall_1());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:893:1: ( (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) ) | ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) ) )?
+ int alt16=3;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0==RULE_EXTENDS) ) {
+ alt16=1;
+ }
+ else if ( (LA16_0==RULE_IDENTIFIER) ) {
+ alt16=2;
+ }
+ switch (alt16) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:893:2: (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:893:2: (this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:893:3: this_EXTENDS_2= RULE_EXTENDS ( (lv_extend_3_0= ruleSuperClass ) ) ( (lv_body_4_0= ruleBlock ) )
+ {
+ this_EXTENDS_2=(Token)match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_ruleAssignedClassDeclaration1900); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EXTENDS_2, grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_0_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:897:1: ( (lv_extend_3_0= ruleSuperClass ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:898:1: (lv_extend_3_0= ruleSuperClass )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:898:1: (lv_extend_3_0= ruleSuperClass )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:899:3: lv_extend_3_0= ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_ruleAssignedClassDeclaration1920);
+ lv_extend_3_0=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "extend",
+ lv_extend_3_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:915:2: ( (lv_body_4_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:916:1: (lv_body_4_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:916:1: (lv_body_4_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:917:3: lv_body_4_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_0_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleAssignedClassDeclaration1941);
+ lv_body_4_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:934:6: ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:934:6: ( ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:934:7: ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) ) (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )? ( (lv_body_8_0= ruleBlock ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:934:7: ( ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:935:1: ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:935:1: ( (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:936:1: (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:936:1: (lv_name_5_1= ruleId | lv_name_5_2= ruleProperty )
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0==RULE_IDENTIFIER) ) {
+ int LA14_1 = input.LA(2);
+
+ if ( (LA14_1==RULE_EXTENDS||LA14_1==RULE_INDENT) ) {
+ alt14=1;
+ }
+ else if ( ((LA14_1>=RULE_DOT && LA14_1<=RULE_INDEX_START)) ) {
+ alt14=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 14, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 14, 0, input);
+
+ throw nvae;
+ }
+ switch (alt14) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:937:3: lv_name_5_1= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getNameIdParserRuleCall_2_1_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleAssignedClassDeclaration1972);
+ lv_name_5_1=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_5_1,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:952:8: lv_name_5_2= ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getNamePropertyParserRuleCall_2_1_0_0_1());
+
+ }
+ pushFollow(FOLLOW_ruleProperty_in_ruleAssignedClassDeclaration1991);
+ lv_name_5_2=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_5_2,
+ "Property");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:970:2: (this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) ) )?
+ int alt15=2;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0==RULE_EXTENDS) ) {
+ alt15=1;
+ }
+ switch (alt15) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:970:3: this_EXTENDS_6= RULE_EXTENDS ( (lv_extend_7_0= ruleSuperClass ) )
+ {
+ this_EXTENDS_6=(Token)match(input,RULE_EXTENDS,FOLLOW_RULE_EXTENDS_in_ruleAssignedClassDeclaration2006); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EXTENDS_6, grammarAccess.getAssignedClassDeclarationAccess().getEXTENDSTerminalRuleCall_2_1_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:974:1: ( (lv_extend_7_0= ruleSuperClass ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:975:1: (lv_extend_7_0= ruleSuperClass )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:975:1: (lv_extend_7_0= ruleSuperClass )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:976:3: lv_extend_7_0= ruleSuperClass
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getExtendSuperClassParserRuleCall_2_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleSuperClass_in_ruleAssignedClassDeclaration2026);
+ lv_extend_7_0=ruleSuperClass();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "extend",
+ lv_extend_7_0,
+ "SuperClass");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:992:4: ( (lv_body_8_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:993:1: (lv_body_8_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:993:1: (lv_body_8_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:994:3: lv_body_8_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedClassDeclarationAccess().getBodyBlockParserRuleCall_2_1_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleAssignedClassDeclaration2049);
+ lv_body_8_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignedClassDeclarationRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_8_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignedClassDeclaration"
+
+
+ // $ANTLR start "entryRuleExpression"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1018:1: entryRuleExpression returns [EObject current=null] : iv_ruleExpression= ruleExpression EOF ;
+ public final EObject entryRuleExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleExpression = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1019:2: (iv_ruleExpression= ruleExpression EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1020:2: iv_ruleExpression= ruleExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getExpressionRule());
+ }
+ pushFollow(FOLLOW_ruleExpression_in_entryRuleExpression2088);
+ iv_ruleExpression=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleExpression;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExpression2098); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleExpression"
+
+
+ // $ANTLR start "ruleExpression"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1027:1: ruleExpression returns [EObject current=null] : this_Postfix_0= rulePostfix ;
+ public final EObject ruleExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Postfix_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1030:28: (this_Postfix_0= rulePostfix )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1032:5: this_Postfix_0= rulePostfix
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExpressionAccess().getPostfixParserRuleCall());
+
+ }
+ pushFollow(FOLLOW_rulePostfix_in_ruleExpression2144);
+ this_Postfix_0=rulePostfix();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Postfix_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleExpression"
+
+
+ // $ANTLR start "entryRulePostfix"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1048:1: entryRulePostfix returns [EObject current=null] : iv_rulePostfix= rulePostfix EOF ;
+ public final EObject entryRulePostfix() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_rulePostfix = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1049:2: (iv_rulePostfix= rulePostfix EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1050:2: iv_rulePostfix= rulePostfix EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getPostfixRule());
+ }
+ pushFollow(FOLLOW_rulePostfix_in_entryRulePostfix2178);
+ iv_rulePostfix=rulePostfix();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_rulePostfix;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRulePostfix2188); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRulePostfix"
+
+
+ // $ANTLR start "rulePostfix"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1057:1: rulePostfix returns [EObject current=null] : (this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )? ) ;
+ public final EObject rulePostfix() throws RecognitionException {
+ EObject current = null;
+
+ Token this_POST_IF_1=null;
+ Token this_FOR_4=null;
+ Token this_WHILE_7=null;
+ Token this_WHEN_10=null;
+ Token this_UNTIL_12=null;
+ Token this_WHEN_15=null;
+ EObject this_Assignment_0 = null;
+
+ EObject lv_condition_3_0 = null;
+
+ EObject lv_body_6_0 = null;
+
+ EObject lv_body_9_0 = null;
+
+ EObject lv_when_11_0 = null;
+
+ EObject lv_body_14_0 = null;
+
+ EObject lv_when_16_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1060:28: ( (this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1061:1: (this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1061:1: (this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1062:5: this_Assignment_0= ruleAssignment ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )?
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getAssignmentParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignment_in_rulePostfix2235);
+ this_Assignment_0=ruleAssignment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Assignment_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1070:1: ( ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )?
+ int alt19=5;
+ alt19 = dfa19.predict(input);
+ switch (alt19) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1070:2: ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1070:2: ( ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1070:3: ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1070:3: ( ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1070:4: ( RULE_POST_IF )=>this_POST_IF_1= RULE_POST_IF
+ {
+ this_POST_IF_1=(Token)match(input,RULE_POST_IF,FOLLOW_RULE_POST_IF_in_rulePostfix2253); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_POST_IF_1, grammarAccess.getPostfixAccess().getPOST_IFTerminalRuleCall_1_0_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1074:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1075:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getIfDummyAction_1_0_1(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1080:2: ( (lv_condition_3_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1081:1: (lv_condition_3_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1081:1: (lv_condition_3_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1082:3: lv_condition_3_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getConditionExpressionParserRuleCall_1_0_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2283);
+ lv_condition_3_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "condition",
+ lv_condition_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1099:6: ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1099:6: ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1099:7: ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1099:7: ( ( RULE_FOR )=>this_FOR_4= RULE_FOR )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1099:8: ( RULE_FOR )=>this_FOR_4= RULE_FOR
+ {
+ this_FOR_4=(Token)match(input,RULE_FOR,FOLLOW_RULE_FOR_in_rulePostfix2308); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FOR_4, grammarAccess.getPostfixAccess().getFORTerminalRuleCall_1_1_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1103:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1104:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getForDummyAction_1_1_1(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1109:2: ( (lv_body_6_0= ruleForBody ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1110:1: (lv_body_6_0= ruleForBody )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1110:1: (lv_body_6_0= ruleForBody )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1111:3: lv_body_6_0= ruleForBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyForBodyParserRuleCall_1_1_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleForBody_in_rulePostfix2338);
+ lv_body_6_0=ruleForBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_6_0,
+ "ForBody");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1128:6: ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1128:6: ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1128:7: ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1128:7: ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1128:8: ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE
+ {
+ this_WHILE_7=(Token)match(input,RULE_WHILE,FOLLOW_RULE_WHILE_in_rulePostfix2363); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHILE_7, grammarAccess.getPostfixAccess().getWHILETerminalRuleCall_1_2_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1132:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1133:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getWhileDummyAction_1_2_1(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1138:2: ( (lv_body_9_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1139:1: (lv_body_9_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1139:1: (lv_body_9_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1140:3: lv_body_9_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_2_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2393);
+ lv_body_9_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_9_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1156:2: ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )?
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( (LA17_0==RULE_WHEN) ) {
+ int LA17_1 = input.LA(2);
+
+ if ( (synpred6_InternalCakefile()) ) {
+ alt17=1;
+ }
+ }
+ switch (alt17) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1156:3: ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1156:3: ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1156:4: ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN
+ {
+ this_WHEN_10=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rulePostfix2411); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_10, grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_2_3_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1160:2: ( (lv_when_11_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1161:1: (lv_when_11_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1161:1: (lv_when_11_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1162:3: lv_when_11_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_2_3_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2432);
+ lv_when_11_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_11_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1179:6: ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1179:6: ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1179:7: ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1179:7: ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1179:8: ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL
+ {
+ this_UNTIL_12=(Token)match(input,RULE_UNTIL,FOLLOW_RULE_UNTIL_in_rulePostfix2459); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_UNTIL_12, grammarAccess.getPostfixAccess().getUNTILTerminalRuleCall_1_3_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1183:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1184:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getPostfixAccess().getUntilDummyAction_1_3_1(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1189:2: ( (lv_body_14_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1190:1: (lv_body_14_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1190:1: (lv_body_14_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1191:3: lv_body_14_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getBodyExpressionParserRuleCall_1_3_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2489);
+ lv_body_14_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_14_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1207:2: ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )?
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0==RULE_WHEN) ) {
+ int LA18_1 = input.LA(2);
+
+ if ( (synpred8_InternalCakefile()) ) {
+ alt18=1;
+ }
+ }
+ switch (alt18) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1207:3: ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1207:3: ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1207:4: ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN
+ {
+ this_WHEN_15=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rulePostfix2507); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_15, grammarAccess.getPostfixAccess().getWHENTerminalRuleCall_1_3_3_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1211:2: ( (lv_when_16_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1212:1: (lv_when_16_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1212:1: (lv_when_16_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1213:3: lv_when_16_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPostfixAccess().getWhenExpressionParserRuleCall_1_3_3_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePostfix2528);
+ lv_when_16_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPostfixRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_16_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "rulePostfix"
+
+
+ // $ANTLR start "entryRuleForBody"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1237:1: entryRuleForBody returns [EObject current=null] : iv_ruleForBody= ruleForBody EOF ;
+ public final EObject entryRuleForBody() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleForBody = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1238:2: (iv_ruleForBody= ruleForBody EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1239:2: iv_ruleForBody= ruleForBody EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getForBodyRule());
+ }
+ pushFollow(FOLLOW_ruleForBody_in_entryRuleForBody2569);
+ iv_ruleForBody=ruleForBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleForBody;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleForBody2579); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleForBody"
+
+
+ // $ANTLR start "ruleForBody"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1246:1: ruleForBody returns [EObject current=null] : ( (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) ) ) ;
+ public final EObject ruleForBody() throws RecognitionException {
+ EObject current = null;
+
+ Token this_OWN_0=null;
+ Token this_COMMA_2=null;
+ EObject lv_indexes_1_0 = null;
+
+ EObject lv_indexes_3_0 = null;
+
+ EObject lv_source_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1249:28: ( ( (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1250:1: ( (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1250:1: ( (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1250:2: (this_OWN_0= RULE_OWN )? ( (lv_indexes_1_0= ruleForValue ) ) (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )* ( (lv_source_4_0= ruleForSource ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1250:2: (this_OWN_0= RULE_OWN )?
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0==RULE_OWN) ) {
+ alt20=1;
+ }
+ switch (alt20) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1250:3: this_OWN_0= RULE_OWN
+ {
+ this_OWN_0=(Token)match(input,RULE_OWN,FOLLOW_RULE_OWN_in_ruleForBody2616); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OWN_0, grammarAccess.getForBodyAccess().getOWNTerminalRuleCall_0());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1254:3: ( (lv_indexes_1_0= ruleForValue ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1255:1: (lv_indexes_1_0= ruleForValue )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1255:1: (lv_indexes_1_0= ruleForValue )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1256:3: lv_indexes_1_0= ruleForValue
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleForValue_in_ruleForBody2638);
+ lv_indexes_1_0=ruleForValue();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ add(
+ current,
+ "indexes",
+ lv_indexes_1_0,
+ "ForValue");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1272:2: (this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) ) )*
+ loop21:
+ do {
+ int alt21=2;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0==RULE_COMMA) ) {
+ alt21=1;
+ }
+
+
+ switch (alt21) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1272:3: this_COMMA_2= RULE_COMMA ( (lv_indexes_3_0= ruleForValue ) )
+ {
+ this_COMMA_2=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleForBody2650); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_2, grammarAccess.getForBodyAccess().getCOMMATerminalRuleCall_2_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1276:1: ( (lv_indexes_3_0= ruleForValue ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1277:1: (lv_indexes_3_0= ruleForValue )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1277:1: (lv_indexes_3_0= ruleForValue )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1278:3: lv_indexes_3_0= ruleForValue
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForBodyAccess().getIndexesForValueParserRuleCall_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleForValue_in_ruleForBody2670);
+ lv_indexes_3_0=ruleForValue();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ add(
+ current,
+ "indexes",
+ lv_indexes_3_0,
+ "ForValue");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop21;
+ }
+ } while (true);
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1294:4: ( (lv_source_4_0= ruleForSource ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1295:1: (lv_source_4_0= ruleForSource )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1295:1: (lv_source_4_0= ruleForSource )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1296:3: lv_source_4_0= ruleForSource
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForBodyAccess().getSourceForSourceParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleForSource_in_ruleForBody2693);
+ lv_source_4_0=ruleForSource();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForBodyRule());
+ }
+ set(
+ current,
+ "source",
+ lv_source_4_0,
+ "ForSource");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleForBody"
+
+
+ // $ANTLR start "entryRuleForValue"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1320:1: entryRuleForValue returns [EObject current=null] : iv_ruleForValue= ruleForValue EOF ;
+ public final EObject entryRuleForValue() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleForValue = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1321:2: (iv_ruleForValue= ruleForValue EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1322:2: iv_ruleForValue= ruleForValue EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getForValueRule());
+ }
+ pushFollow(FOLLOW_ruleForValue_in_entryRuleForValue2729);
+ iv_ruleForValue=ruleForValue();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleForValue;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleForValue2739); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleForValue"
+
+
+ // $ANTLR start "ruleForValue"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1329:1: ruleForValue returns [EObject current=null] : this_Id_0= ruleId ;
+ public final EObject ruleForValue() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Id_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1332:28: (this_Id_0= ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1334:5: this_Id_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForValueAccess().getIdParserRuleCall());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleForValue2785);
+ this_Id_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleForValue"
+
+
+ // $ANTLR start "entryRuleForSource"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1350:1: entryRuleForSource returns [EObject current=null] : iv_ruleForSource= ruleForSource EOF ;
+ public final EObject entryRuleForSource() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleForSource = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1351:2: (iv_ruleForSource= ruleForSource EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1352:2: iv_ruleForSource= ruleForSource EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getForSourceRule());
+ }
+ pushFollow(FOLLOW_ruleForSource_in_entryRuleForSource2819);
+ iv_ruleForSource=ruleForSource();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleForSource;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleForSource2829); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleForSource"
+
+
+ // $ANTLR start "ruleForSource"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1359:1: ruleForSource returns [EObject current=null] : ( () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) ) ) ;
+ public final EObject ruleForSource() throws RecognitionException {
+ EObject current = null;
+
+ Token this_FOROF_1=null;
+ Token this_WHEN_3=null;
+ Token this_FORIN_5=null;
+ Token this_WHEN_7=null;
+ Token this_BY_9=null;
+ Token this_BY_11=null;
+ Token this_WHEN_13=null;
+ EObject lv_source_2_0 = null;
+
+ EObject lv_when_4_0 = null;
+
+ EObject lv_source_6_0 = null;
+
+ EObject lv_when_8_0 = null;
+
+ EObject lv_by_10_0 = null;
+
+ EObject lv_by_12_0 = null;
+
+ EObject lv_when_14_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1362:28: ( ( () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1363:1: ( () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1363:1: ( () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1363:2: () ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1363:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1364:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getForSourceAccess().getForSourceAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1369:2: ( ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? ) | ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? ) )
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0==RULE_FOROF) && (synpred9_InternalCakefile())) {
+ alt26=1;
+ }
+ else if ( (LA26_0==RULE_FORIN) && (synpred11_InternalCakefile())) {
+ alt26=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 26, 0, input);
+
+ throw nvae;
+ }
+ switch (alt26) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1369:3: ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1369:3: ( ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1369:4: ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF ) ( (lv_source_2_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1369:4: ( ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1369:5: ( RULE_FOROF )=>this_FOROF_1= RULE_FOROF
+ {
+ this_FOROF_1=(Token)match(input,RULE_FOROF,FOLLOW_RULE_FOROF_in_ruleForSource2882); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FOROF_1, grammarAccess.getForSourceAccess().getFOROFTerminalRuleCall_1_0_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1373:2: ( (lv_source_2_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1374:1: (lv_source_2_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1374:1: (lv_source_2_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1375:3: lv_source_2_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2903);
+ lv_source_2_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "source",
+ lv_source_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1391:2: ( ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) ) )?
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( (LA22_0==RULE_WHEN) ) {
+ int LA22_1 = input.LA(2);
+
+ if ( (synpred10_InternalCakefile()) ) {
+ alt22=1;
+ }
+ }
+ switch (alt22) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1391:3: ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN ) ( (lv_when_4_0= ruleExpression ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1391:3: ( ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1391:4: ( RULE_WHEN )=>this_WHEN_3= RULE_WHEN
+ {
+ this_WHEN_3=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_ruleForSource2921); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_3, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_0_2_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1395:2: ( (lv_when_4_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1396:1: (lv_when_4_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1396:1: (lv_when_4_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1397:3: lv_when_4_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_0_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2942);
+ lv_when_4_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1414:6: ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1414:6: ( ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1414:7: ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN ) ( (lv_source_6_0= ruleExpression ) ) ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1414:7: ( ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1414:8: ( RULE_FORIN )=>this_FORIN_5= RULE_FORIN
+ {
+ this_FORIN_5=(Token)match(input,RULE_FORIN,FOLLOW_RULE_FORIN_in_ruleForSource2969); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FORIN_5, grammarAccess.getForSourceAccess().getFORINTerminalRuleCall_1_1_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1418:2: ( (lv_source_6_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1419:1: (lv_source_6_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1419:1: (lv_source_6_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1420:3: lv_source_6_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getSourceExpressionParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource2990);
+ lv_source_6_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "source",
+ lv_source_6_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1436:2: ( ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? ) | ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? ) )?
+ int alt25=3;
+ int LA25_0 = input.LA(1);
+
+ if ( (LA25_0==RULE_WHEN) ) {
+ int LA25_1 = input.LA(2);
+
+ if ( (synpred12_InternalCakefile()) ) {
+ alt25=1;
+ }
+ }
+ else if ( (LA25_0==RULE_BY) ) {
+ int LA25_2 = input.LA(2);
+
+ if ( (synpred14_InternalCakefile()) ) {
+ alt25=2;
+ }
+ }
+ switch (alt25) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1436:3: ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1436:3: ( ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1436:4: ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN ) ( (lv_when_8_0= ruleExpression ) ) ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1436:4: ( ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1436:5: ( RULE_WHEN )=>this_WHEN_7= RULE_WHEN
+ {
+ this_WHEN_7=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_ruleForSource3009); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_7, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_0_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1440:2: ( (lv_when_8_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1441:1: (lv_when_8_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1441:1: (lv_when_8_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1442:3: lv_when_8_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource3030);
+ lv_when_8_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_8_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1458:2: ( ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) ) )?
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( (LA23_0==RULE_BY) ) {
+ int LA23_1 = input.LA(2);
+
+ if ( (synpred13_InternalCakefile()) ) {
+ alt23=1;
+ }
+ }
+ switch (alt23) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1458:3: ( ( RULE_BY )=>this_BY_9= RULE_BY ) ( (lv_by_10_0= ruleExpression ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1458:3: ( ( RULE_BY )=>this_BY_9= RULE_BY )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1458:4: ( RULE_BY )=>this_BY_9= RULE_BY
+ {
+ this_BY_9=(Token)match(input,RULE_BY,FOLLOW_RULE_BY_in_ruleForSource3048); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_BY_9, grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_0_2_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1462:2: ( (lv_by_10_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1463:1: (lv_by_10_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1463:1: (lv_by_10_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1464:3: lv_by_10_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_0_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource3069);
+ lv_by_10_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "by",
+ lv_by_10_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1481:6: ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1481:6: ( ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1481:7: ( ( RULE_BY )=>this_BY_11= RULE_BY ) ( (lv_by_12_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1481:7: ( ( RULE_BY )=>this_BY_11= RULE_BY )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1481:8: ( RULE_BY )=>this_BY_11= RULE_BY
+ {
+ this_BY_11=(Token)match(input,RULE_BY,FOLLOW_RULE_BY_in_ruleForSource3096); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_BY_11, grammarAccess.getForSourceAccess().getBYTerminalRuleCall_1_1_2_1_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1485:2: ( (lv_by_12_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1486:1: (lv_by_12_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1486:1: (lv_by_12_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1487:3: lv_by_12_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getByExpressionParserRuleCall_1_1_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource3117);
+ lv_by_12_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "by",
+ lv_by_12_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1503:2: ( ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) ) )?
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0==RULE_WHEN) ) {
+ int LA24_1 = input.LA(2);
+
+ if ( (synpred15_InternalCakefile()) ) {
+ alt24=1;
+ }
+ }
+ switch (alt24) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1503:3: ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN ) ( (lv_when_14_0= ruleExpression ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1503:3: ( ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1503:4: ( RULE_WHEN )=>this_WHEN_13= RULE_WHEN
+ {
+ this_WHEN_13=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_ruleForSource3135); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_13, grammarAccess.getForSourceAccess().getWHENTerminalRuleCall_1_1_2_1_2_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1507:2: ( (lv_when_14_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1508:1: (lv_when_14_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1508:1: (lv_when_14_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1509:3: lv_when_14_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getForSourceAccess().getWhenExpressionParserRuleCall_1_1_2_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleForSource3156);
+ lv_when_14_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getForSourceRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_14_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleForSource"
+
+
+ // $ANTLR start "entryRuleRange"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1533:1: entryRuleRange returns [EObject current=null] : iv_ruleRange= ruleRange EOF ;
+ public final EObject entryRuleRange() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRange = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1534:2: (iv_ruleRange= ruleRange EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1535:2: iv_ruleRange= ruleRange EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getRangeRule());
+ }
+ pushFollow(FOLLOW_ruleRange_in_entryRuleRange3199);
+ iv_ruleRange=ruleRange();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleRange;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRange3209); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRange"
+
+
+ // $ANTLR start "ruleRange"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1542:1: ruleRange returns [EObject current=null] : ( ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET ) ;
+ public final EObject ruleRange() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LBRACKET_0=null;
+ Token this_DOT_DOT_2=null;
+ Token this_ELLIPSIS_3=null;
+ Token this_RBRACKET_5=null;
+ EObject lv_start_1_0 = null;
+
+ EObject lv_end_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1545:28: ( ( ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1546:1: ( ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1546:1: ( ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1546:2: ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) ) ( (lv_end_4_0= ruleExpression ) ) this_RBRACKET_5= RULE_RBRACKET
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1546:2: ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1546:3: ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1551:25: (this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1551:26: this_LBRACKET_0= RULE_LBRACKET ( (lv_start_1_0= ruleExpression ) ) (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS )
+ {
+ this_LBRACKET_0=(Token)match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_ruleRange3275); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LBRACKET_0, grammarAccess.getRangeAccess().getLBRACKETTerminalRuleCall_0_0_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1555:1: ( (lv_start_1_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1556:1: (lv_start_1_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1556:1: (lv_start_1_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1557:3: lv_start_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRangeAccess().getStartExpressionParserRuleCall_0_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleRange3295);
+ lv_start_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRangeRule());
+ }
+ set(
+ current,
+ "start",
+ lv_start_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1573:2: (this_DOT_DOT_2= RULE_DOT_DOT | this_ELLIPSIS_3= RULE_ELLIPSIS )
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( (LA27_0==RULE_DOT_DOT) ) {
+ alt27=1;
+ }
+ else if ( (LA27_0==RULE_ELLIPSIS) ) {
+ alt27=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 27, 0, input);
+
+ throw nvae;
+ }
+ switch (alt27) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1573:3: this_DOT_DOT_2= RULE_DOT_DOT
+ {
+ this_DOT_DOT_2=(Token)match(input,RULE_DOT_DOT,FOLLOW_RULE_DOT_DOT_in_ruleRange3307); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_DOT_DOT_2, grammarAccess.getRangeAccess().getDOT_DOTTerminalRuleCall_0_0_2_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1578:6: this_ELLIPSIS_3= RULE_ELLIPSIS
+ {
+ this_ELLIPSIS_3=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleRange3323); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_ELLIPSIS_3, grammarAccess.getRangeAccess().getELLIPSISTerminalRuleCall_0_0_2_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1582:4: ( (lv_end_4_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1583:1: (lv_end_4_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1583:1: (lv_end_4_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1584:3: lv_end_4_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRangeAccess().getEndExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleRange3346);
+ lv_end_4_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRangeRule());
+ }
+ set(
+ current,
+ "end",
+ lv_end_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_RBRACKET_5=(Token)match(input,RULE_RBRACKET,FOLLOW_RULE_RBRACKET_in_ruleRange3357); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RBRACKET_5, grammarAccess.getRangeAccess().getRBRACKETTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRange"
+
+
+ // $ANTLR start "entryRuleAssignment"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1612:1: entryRuleAssignment returns [EObject current=null] : iv_ruleAssignment= ruleAssignment EOF ;
+ public final EObject entryRuleAssignment() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignment = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1613:2: (iv_ruleAssignment= ruleAssignment EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1614:2: iv_ruleAssignment= ruleAssignment EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignmentRule());
+ }
+ pushFollow(FOLLOW_ruleAssignment_in_entryRuleAssignment3392);
+ iv_ruleAssignment=ruleAssignment();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignment;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignment3402); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignment"
+
+
+ // $ANTLR start "ruleAssignment"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1621:1: ruleAssignment returns [EObject current=null] : ( ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp ) ;
+ public final EObject ruleAssignment() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_1_1=null;
+ Token lv_operator_1_2=null;
+ EObject lv_left_0_0 = null;
+
+ EObject lv_right_2_0 = null;
+
+ EObject this_LogicOp_3 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1624:28: ( ( ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:1: ( ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:1: ( ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp )
+ int alt29=2;
+ alt29 = dfa29.predict(input);
+ switch (alt29) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:2: ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:2: ( ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:3: ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:3: ( ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:4: ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )=> ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1639:6: ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1639:7: ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1639:7: ( (lv_left_0_0= ruleAssignable ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1640:1: (lv_left_0_0= ruleAssignable )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1640:1: (lv_left_0_0= ruleAssignable )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1641:3: lv_left_0_0= ruleAssignable
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignmentAccess().getLeftAssignableParserRuleCall_0_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignable_in_ruleAssignment3490);
+ lv_left_0_0=ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignmentRule());
+ }
+ set(
+ current,
+ "left",
+ lv_left_0_0,
+ "Assignable");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1657:2: ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1658:1: ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1658:1: ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1659:1: (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1659:1: (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN )
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( (LA28_0==RULE_EQUAL) ) {
+ alt28=1;
+ }
+ else if ( (LA28_0==RULE_COMPOUND_ASSIGN) ) {
+ alt28=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 28, 0, input);
+
+ throw nvae;
+ }
+ switch (alt28) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1660:3: lv_operator_1_1= RULE_EQUAL
+ {
+ lv_operator_1_1=(Token)match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_ruleAssignment3509); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_1_1, grammarAccess.getAssignmentAccess().getOperatorEQUALTerminalRuleCall_0_0_0_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAssignmentRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_1_1,
+ "EQUAL");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1675:8: lv_operator_1_2= RULE_COMPOUND_ASSIGN
+ {
+ lv_operator_1_2=(Token)match(input,RULE_COMPOUND_ASSIGN,FOLLOW_RULE_COMPOUND_ASSIGN_in_ruleAssignment3529); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_1_2, grammarAccess.getAssignmentAccess().getOperatorCOMPOUND_ASSIGNTerminalRuleCall_0_0_0_1_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAssignmentRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_1_2,
+ "COMPOUND_ASSIGN");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1693:4: ( (lv_right_2_0= ruleAssigned ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1694:1: (lv_right_2_0= ruleAssigned )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1694:1: (lv_right_2_0= ruleAssigned )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1695:3: lv_right_2_0= ruleAssigned
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignmentAccess().getRightAssignedParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssigned_in_ruleAssignment3560);
+ lv_right_2_0=ruleAssigned();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignmentRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_2_0,
+ "Assigned");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1713:5: this_LogicOp_3= ruleLogicOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignmentAccess().getLogicOpParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleLogicOp_in_ruleAssignment3589);
+ this_LogicOp_3=ruleLogicOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_LogicOp_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignment"
+
+
+ // $ANTLR start "entryRuleAssigned"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1729:1: entryRuleAssigned returns [EObject current=null] : iv_ruleAssigned= ruleAssigned EOF ;
+ public final EObject entryRuleAssigned() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssigned = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1730:2: (iv_ruleAssigned= ruleAssigned EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1731:2: iv_ruleAssigned= ruleAssigned EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignedRule());
+ }
+ pushFollow(FOLLOW_ruleAssigned_in_entryRuleAssigned3624);
+ iv_ruleAssigned=ruleAssigned();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssigned;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssigned3634); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssigned"
+
+
+ // $ANTLR start "ruleAssigned"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1738:1: ruleAssigned returns [EObject current=null] : (this_Expression_0= ruleExpression | (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT ) | this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration ) ;
+ public final EObject ruleAssigned() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDENT_1=null;
+ Token this_OUTDENT_3=null;
+ EObject this_Expression_0 = null;
+
+ EObject this_Expression_2 = null;
+
+ EObject this_AssignedClassDeclaration_4 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1741:28: ( (this_Expression_0= ruleExpression | (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT ) | this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1742:1: (this_Expression_0= ruleExpression | (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT ) | this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1742:1: (this_Expression_0= ruleExpression | (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT ) | this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration )
+ int alt30=3;
+ switch ( input.LA(1) ) {
+ case RULE_PARAM_START:
+ case RULE_FUNC_ARROW:
+ case RULE_STRING:
+ case RULE_FOR:
+ case RULE_WHILE:
+ case RULE_UNTIL:
+ case RULE_LBRACKET:
+ case RULE_PLUS:
+ case RULE_MINUS:
+ case RULE_UNARY:
+ case RULE_PLUS_PLUS:
+ case RULE_MINUS_MINUS:
+ case RULE_SUPER:
+ case RULE_AT_SIGIL:
+ case RULE_THIS:
+ case RULE_LOOP:
+ case RULE_TRY:
+ case RULE_SWITCH:
+ case RULE_IF:
+ case RULE_IDENTIFIER:
+ case RULE_LCURLY:
+ case RULE_BOUND_FUNC_ARROW:
+ case RULE_NUMBER:
+ case RULE_BOOL:
+ case RULE_JS:
+ case RULE_REGEX:
+ case RULE_LPAREN:
+ {
+ alt30=1;
+ }
+ break;
+ case RULE_INDENT:
+ {
+ alt30=2;
+ }
+ break;
+ case RULE_CLASS:
+ {
+ alt30=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 30, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt30) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1743:5: this_Expression_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleAssigned3681);
+ this_Expression_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Expression_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1752:6: (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1752:6: (this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1752:7: this_INDENT_1= RULE_INDENT this_Expression_2= ruleExpression this_OUTDENT_3= RULE_OUTDENT
+ {
+ this_INDENT_1=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleAssigned3698); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_1, grammarAccess.getAssignedAccess().getINDENTTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedAccess().getExpressionParserRuleCall_1_1());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleAssigned3719);
+ this_Expression_2=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Expression_2;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_OUTDENT_3=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleAssigned3729); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_3, grammarAccess.getAssignedAccess().getOUTDENTTerminalRuleCall_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1771:5: this_AssignedClassDeclaration_4= ruleAssignedClassDeclaration
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignedAccess().getAssignedClassDeclarationParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleAssignedClassDeclaration_in_ruleAssigned3757);
+ this_AssignedClassDeclaration_4=ruleAssignedClassDeclaration();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_AssignedClassDeclaration_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssigned"
+
+
+ // $ANTLR start "entryRuleLogicOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1787:1: entryRuleLogicOp returns [EObject current=null] : iv_ruleLogicOp= ruleLogicOp EOF ;
+ public final EObject entryRuleLogicOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleLogicOp = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1788:2: (iv_ruleLogicOp= ruleLogicOp EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1789:2: iv_ruleLogicOp= ruleLogicOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getLogicOpRule());
+ }
+ pushFollow(FOLLOW_ruleLogicOp_in_entryRuleLogicOp3792);
+ iv_ruleLogicOp=ruleLogicOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleLogicOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLogicOp3802); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleLogicOp"
+
+
+ // $ANTLR start "ruleLogicOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1796:1: ruleLogicOp returns [EObject current=null] : (this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )* ) ;
+ public final EObject ruleLogicOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_CompareOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1799:28: ( (this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1800:1: (this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1800:1: (this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1801:5: this_CompareOp_0= ruleCompareOp ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLogicOpAccess().getCompareOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleCompareOp_in_ruleLogicOp3849);
+ this_CompareOp_0=ruleCompareOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_CompareOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1809:1: ( ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) ) )*
+ loop31:
+ do {
+ int alt31=2;
+ int LA31_0 = input.LA(1);
+
+ if ( (LA31_0==RULE_LOGIC) ) {
+ int LA31_2 = input.LA(2);
+
+ if ( (synpred18_InternalCakefile()) ) {
+ alt31=1;
+ }
+
+
+ }
+
+
+ switch (alt31) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1809:2: ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) ) ( (lv_right_3_0= ruleCompareOp ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1809:2: ( ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1809:3: ( ( () ( ( RULE_LOGIC ) ) ) )=> ( () ( (lv_operator_2_0= RULE_LOGIC ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1815:6: ( () ( (lv_operator_2_0= RULE_LOGIC ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1815:7: () ( (lv_operator_2_0= RULE_LOGIC ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1815:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1816:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getLogicOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1821:2: ( (lv_operator_2_0= RULE_LOGIC ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1822:1: (lv_operator_2_0= RULE_LOGIC )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1822:1: (lv_operator_2_0= RULE_LOGIC )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1823:3: lv_operator_2_0= RULE_LOGIC
+ {
+ lv_operator_2_0=(Token)match(input,RULE_LOGIC,FOLLOW_RULE_LOGIC_in_ruleLogicOp3895); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getLogicOpAccess().getOperatorLOGICTerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getLogicOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "LOGIC");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1839:4: ( (lv_right_3_0= ruleCompareOp ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1840:1: (lv_right_3_0= ruleCompareOp )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1840:1: (lv_right_3_0= ruleCompareOp )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1841:3: lv_right_3_0= ruleCompareOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLogicOpAccess().getRightCompareOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleCompareOp_in_ruleLogicOp3923);
+ lv_right_3_0=ruleCompareOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getLogicOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "CompareOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop31;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleLogicOp"
+
+
+ // $ANTLR start "entryRuleCompareOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1865:1: entryRuleCompareOp returns [EObject current=null] : iv_ruleCompareOp= ruleCompareOp EOF ;
+ public final EObject entryRuleCompareOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleCompareOp = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1866:2: (iv_ruleCompareOp= ruleCompareOp EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1867:2: iv_ruleCompareOp= ruleCompareOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getCompareOpRule());
+ }
+ pushFollow(FOLLOW_ruleCompareOp_in_entryRuleCompareOp3961);
+ iv_ruleCompareOp=ruleCompareOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleCompareOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCompareOp3971); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleCompareOp"
+
+
+ // $ANTLR start "ruleCompareOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1874:1: ruleCompareOp returns [EObject current=null] : (this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )* ) ;
+ public final EObject ruleCompareOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_RelationOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1877:28: ( (this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1878:1: (this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1878:1: (this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1879:5: this_RelationOp_0= ruleRelationOp ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCompareOpAccess().getRelationOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleRelationOp_in_ruleCompareOp4018);
+ this_RelationOp_0=ruleRelationOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_RelationOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1887:1: ( ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) ) )*
+ loop32:
+ do {
+ int alt32=2;
+ int LA32_0 = input.LA(1);
+
+ if ( (LA32_0==RULE_COMPARE) ) {
+ int LA32_2 = input.LA(2);
+
+ if ( (synpred19_InternalCakefile()) ) {
+ alt32=1;
+ }
+
+
+ }
+
+
+ switch (alt32) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1887:2: ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) ) ( (lv_right_3_0= ruleRelationOp ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1887:2: ( ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1887:3: ( ( () ( ( RULE_COMPARE ) ) ) )=> ( () ( (lv_operator_2_0= RULE_COMPARE ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1893:6: ( () ( (lv_operator_2_0= RULE_COMPARE ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1893:7: () ( (lv_operator_2_0= RULE_COMPARE ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1893:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1894:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getCompareOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1899:2: ( (lv_operator_2_0= RULE_COMPARE ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1900:1: (lv_operator_2_0= RULE_COMPARE )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1900:1: (lv_operator_2_0= RULE_COMPARE )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1901:3: lv_operator_2_0= RULE_COMPARE
+ {
+ lv_operator_2_0=(Token)match(input,RULE_COMPARE,FOLLOW_RULE_COMPARE_in_ruleCompareOp4064); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getCompareOpAccess().getOperatorCOMPARETerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getCompareOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "COMPARE");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1917:4: ( (lv_right_3_0= ruleRelationOp ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1918:1: (lv_right_3_0= ruleRelationOp )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1918:1: (lv_right_3_0= ruleRelationOp )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1919:3: lv_right_3_0= ruleRelationOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCompareOpAccess().getRightRelationOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleRelationOp_in_ruleCompareOp4092);
+ lv_right_3_0=ruleRelationOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCompareOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "RelationOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop32;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleCompareOp"
+
+
+ // $ANTLR start "entryRuleRelationOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1943:1: entryRuleRelationOp returns [EObject current=null] : iv_ruleRelationOp= ruleRelationOp EOF ;
+ public final EObject entryRuleRelationOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRelationOp = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1944:2: (iv_ruleRelationOp= ruleRelationOp EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1945:2: iv_ruleRelationOp= ruleRelationOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getRelationOpRule());
+ }
+ pushFollow(FOLLOW_ruleRelationOp_in_entryRuleRelationOp4130);
+ iv_ruleRelationOp=ruleRelationOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleRelationOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRelationOp4140); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRelationOp"
+
+
+ // $ANTLR start "ruleRelationOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1952:1: ruleRelationOp returns [EObject current=null] : (this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )* ) ;
+ public final EObject ruleRelationOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_ShiftOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1955:28: ( (this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1956:1: (this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1956:1: (this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1957:5: this_ShiftOp_0= ruleShiftOp ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRelationOpAccess().getShiftOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleShiftOp_in_ruleRelationOp4187);
+ this_ShiftOp_0=ruleShiftOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ShiftOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1965:1: ( ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) ) )*
+ loop33:
+ do {
+ int alt33=2;
+ int LA33_0 = input.LA(1);
+
+ if ( (LA33_0==RULE_RELATION) ) {
+ int LA33_2 = input.LA(2);
+
+ if ( (synpred20_InternalCakefile()) ) {
+ alt33=1;
+ }
+
+
+ }
+
+
+ switch (alt33) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1965:2: ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) ) ( (lv_right_3_0= ruleShiftOp ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1965:2: ( ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1965:3: ( ( () ( ( RULE_RELATION ) ) ) )=> ( () ( (lv_operator_2_0= RULE_RELATION ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1971:6: ( () ( (lv_operator_2_0= RULE_RELATION ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1971:7: () ( (lv_operator_2_0= RULE_RELATION ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1971:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1972:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getRelationOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1977:2: ( (lv_operator_2_0= RULE_RELATION ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1978:1: (lv_operator_2_0= RULE_RELATION )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1978:1: (lv_operator_2_0= RULE_RELATION )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1979:3: lv_operator_2_0= RULE_RELATION
+ {
+ lv_operator_2_0=(Token)match(input,RULE_RELATION,FOLLOW_RULE_RELATION_in_ruleRelationOp4233); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getRelationOpAccess().getOperatorRELATIONTerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRelationOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "RELATION");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1995:4: ( (lv_right_3_0= ruleShiftOp ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1996:1: (lv_right_3_0= ruleShiftOp )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1996:1: (lv_right_3_0= ruleShiftOp )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1997:3: lv_right_3_0= ruleShiftOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getRelationOpAccess().getRightShiftOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleShiftOp_in_ruleRelationOp4261);
+ lv_right_3_0=ruleShiftOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRelationOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "ShiftOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop33;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRelationOp"
+
+
+ // $ANTLR start "entryRuleShiftOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2021:1: entryRuleShiftOp returns [EObject current=null] : iv_ruleShiftOp= ruleShiftOp EOF ;
+ public final EObject entryRuleShiftOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleShiftOp = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2022:2: (iv_ruleShiftOp= ruleShiftOp EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2023:2: iv_ruleShiftOp= ruleShiftOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getShiftOpRule());
+ }
+ pushFollow(FOLLOW_ruleShiftOp_in_entryRuleShiftOp4299);
+ iv_ruleShiftOp=ruleShiftOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleShiftOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleShiftOp4309); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleShiftOp"
+
+
+ // $ANTLR start "ruleShiftOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2030:1: ruleShiftOp returns [EObject current=null] : (this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )* ) ;
+ public final EObject ruleShiftOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_AdditiveOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2033:28: ( (this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2034:1: (this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2034:1: (this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2035:5: this_AdditiveOp_0= ruleAdditiveOp ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getShiftOpAccess().getAdditiveOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleAdditiveOp_in_ruleShiftOp4356);
+ this_AdditiveOp_0=ruleAdditiveOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_AdditiveOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2043:1: ( ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) ) )*
+ loop34:
+ do {
+ int alt34=2;
+ int LA34_0 = input.LA(1);
+
+ if ( (LA34_0==RULE_SHIFT) ) {
+ int LA34_2 = input.LA(2);
+
+ if ( (synpred21_InternalCakefile()) ) {
+ alt34=1;
+ }
+
+
+ }
+
+
+ switch (alt34) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2043:2: ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) ) ( (lv_right_3_0= ruleAdditiveOp ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2043:2: ( ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2043:3: ( ( () ( ( RULE_SHIFT ) ) ) )=> ( () ( (lv_operator_2_0= RULE_SHIFT ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2049:6: ( () ( (lv_operator_2_0= RULE_SHIFT ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2049:7: () ( (lv_operator_2_0= RULE_SHIFT ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2049:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2050:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getShiftOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2055:2: ( (lv_operator_2_0= RULE_SHIFT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2056:1: (lv_operator_2_0= RULE_SHIFT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2056:1: (lv_operator_2_0= RULE_SHIFT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2057:3: lv_operator_2_0= RULE_SHIFT
+ {
+ lv_operator_2_0=(Token)match(input,RULE_SHIFT,FOLLOW_RULE_SHIFT_in_ruleShiftOp4402); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getShiftOpAccess().getOperatorSHIFTTerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getShiftOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "SHIFT");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2073:4: ( (lv_right_3_0= ruleAdditiveOp ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2074:1: (lv_right_3_0= ruleAdditiveOp )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2074:1: (lv_right_3_0= ruleAdditiveOp )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2075:3: lv_right_3_0= ruleAdditiveOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getShiftOpAccess().getRightAdditiveOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleAdditiveOp_in_ruleShiftOp4430);
+ lv_right_3_0=ruleAdditiveOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getShiftOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "AdditiveOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop34;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleShiftOp"
+
+
+ // $ANTLR start "entryRuleAdditiveOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2099:1: entryRuleAdditiveOp returns [EObject current=null] : iv_ruleAdditiveOp= ruleAdditiveOp EOF ;
+ public final EObject entryRuleAdditiveOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAdditiveOp = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2100:2: (iv_ruleAdditiveOp= ruleAdditiveOp EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2101:2: iv_ruleAdditiveOp= ruleAdditiveOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAdditiveOpRule());
+ }
+ pushFollow(FOLLOW_ruleAdditiveOp_in_entryRuleAdditiveOp4468);
+ iv_ruleAdditiveOp=ruleAdditiveOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAdditiveOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAdditiveOp4478); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAdditiveOp"
+
+
+ // $ANTLR start "ruleAdditiveOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2108:1: ruleAdditiveOp returns [EObject current=null] : (this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )* ) ;
+ public final EObject ruleAdditiveOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_1=null;
+ Token lv_operator_2_2=null;
+ EObject this_MathOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2111:28: ( (this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2112:1: (this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2112:1: (this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2113:5: this_MathOp_0= ruleMathOp ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAdditiveOpAccess().getMathOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleMathOp_in_ruleAdditiveOp4525);
+ this_MathOp_0=ruleMathOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_MathOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2121:1: ( ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) ) )*
+ loop36:
+ do {
+ int alt36=2;
+ int LA36_0 = input.LA(1);
+
+ if ( (LA36_0==RULE_PLUS) ) {
+ int LA36_2 = input.LA(2);
+
+ if ( (synpred22_InternalCakefile()) ) {
+ alt36=1;
+ }
+
+
+ }
+ else if ( (LA36_0==RULE_MINUS) ) {
+ int LA36_3 = input.LA(2);
+
+ if ( (synpred22_InternalCakefile()) ) {
+ alt36=1;
+ }
+
+
+ }
+
+
+ switch (alt36) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2121:2: ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) ) ( (lv_right_3_0= ruleMathOp ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2121:2: ( ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2121:3: ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )=> ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2132:6: ( () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2132:7: () ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2132:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2133:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getAdditiveOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2138:2: ( ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2139:1: ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2139:1: ( (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2140:1: (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2140:1: (lv_operator_2_1= RULE_PLUS | lv_operator_2_2= RULE_MINUS )
+ int alt35=2;
+ int LA35_0 = input.LA(1);
+
+ if ( (LA35_0==RULE_PLUS) ) {
+ alt35=1;
+ }
+ else if ( (LA35_0==RULE_MINUS) ) {
+ alt35=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 35, 0, input);
+
+ throw nvae;
+ }
+ switch (alt35) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2141:3: lv_operator_2_1= RULE_PLUS
+ {
+ lv_operator_2_1=(Token)match(input,RULE_PLUS,FOLLOW_RULE_PLUS_in_ruleAdditiveOp4588); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_1, grammarAccess.getAdditiveOpAccess().getOperatorPLUSTerminalRuleCall_1_0_0_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAdditiveOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_1,
+ "PLUS");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2156:8: lv_operator_2_2= RULE_MINUS
+ {
+ lv_operator_2_2=(Token)match(input,RULE_MINUS,FOLLOW_RULE_MINUS_in_ruleAdditiveOp4608); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_2, grammarAccess.getAdditiveOpAccess().getOperatorMINUSTerminalRuleCall_1_0_0_1_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAdditiveOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_2,
+ "MINUS");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2174:4: ( (lv_right_3_0= ruleMathOp ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2175:1: (lv_right_3_0= ruleMathOp )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2175:1: (lv_right_3_0= ruleMathOp )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2176:3: lv_right_3_0= ruleMathOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAdditiveOpAccess().getRightMathOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleMathOp_in_ruleAdditiveOp4639);
+ lv_right_3_0=ruleMathOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAdditiveOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "MathOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop36;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAdditiveOp"
+
+
+ // $ANTLR start "entryRuleMathOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2200:1: entryRuleMathOp returns [EObject current=null] : iv_ruleMathOp= ruleMathOp EOF ;
+ public final EObject entryRuleMathOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleMathOp = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2201:2: (iv_ruleMathOp= ruleMathOp EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2202:2: iv_ruleMathOp= ruleMathOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getMathOpRule());
+ }
+ pushFollow(FOLLOW_ruleMathOp_in_entryRuleMathOp4677);
+ iv_ruleMathOp=ruleMathOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleMathOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleMathOp4687); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleMathOp"
+
+
+ // $ANTLR start "ruleMathOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2209:1: ruleMathOp returns [EObject current=null] : (this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )* ) ;
+ public final EObject ruleMathOp() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_2_0=null;
+ EObject this_UnaryOp_0 = null;
+
+ EObject lv_right_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2212:28: ( (this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2213:1: (this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2213:1: (this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2214:5: this_UnaryOp_0= ruleUnaryOp ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )*
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getMathOpAccess().getUnaryOpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleUnaryOp_in_ruleMathOp4734);
+ this_UnaryOp_0=ruleUnaryOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_UnaryOp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2222:1: ( ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) ) )*
+ loop37:
+ do {
+ int alt37=2;
+ int LA37_0 = input.LA(1);
+
+ if ( (LA37_0==RULE_MATH) ) {
+ int LA37_2 = input.LA(2);
+
+ if ( (synpred23_InternalCakefile()) ) {
+ alt37=1;
+ }
+
+
+ }
+
+
+ switch (alt37) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2222:2: ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) ) ( (lv_right_3_0= ruleUnaryOp ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2222:2: ( ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2222:3: ( ( () ( ( RULE_MATH ) ) ) )=> ( () ( (lv_operator_2_0= RULE_MATH ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2228:6: ( () ( (lv_operator_2_0= RULE_MATH ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2228:7: () ( (lv_operator_2_0= RULE_MATH ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2228:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2229:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElementAndSet(
+ grammarAccess.getMathOpAccess().getBinaryExpLeftAction_1_0_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2234:2: ( (lv_operator_2_0= RULE_MATH ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2235:1: (lv_operator_2_0= RULE_MATH )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2235:1: (lv_operator_2_0= RULE_MATH )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2236:3: lv_operator_2_0= RULE_MATH
+ {
+ lv_operator_2_0=(Token)match(input,RULE_MATH,FOLLOW_RULE_MATH_in_ruleMathOp4780); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_2_0, grammarAccess.getMathOpAccess().getOperatorMATHTerminalRuleCall_1_0_0_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getMathOpRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_2_0,
+ "MATH");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2252:4: ( (lv_right_3_0= ruleUnaryOp ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2253:1: (lv_right_3_0= ruleUnaryOp )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2253:1: (lv_right_3_0= ruleUnaryOp )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2254:3: lv_right_3_0= ruleUnaryOp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getMathOpAccess().getRightUnaryOpParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleUnaryOp_in_ruleMathOp4808);
+ lv_right_3_0=ruleUnaryOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getMathOpRule());
+ }
+ set(
+ current,
+ "right",
+ lv_right_3_0,
+ "UnaryOp");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop37;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleMathOp"
+
+
+ // $ANTLR start "entryRuleUnaryOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2278:1: entryRuleUnaryOp returns [EObject current=null] : iv_ruleUnaryOp= ruleUnaryOp EOF ;
+ public final EObject entryRuleUnaryOp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleUnaryOp = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2279:2: (iv_ruleUnaryOp= ruleUnaryOp EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2280:2: iv_ruleUnaryOp= ruleUnaryOp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getUnaryOpRule());
+ }
+ pushFollow(FOLLOW_ruleUnaryOp_in_entryRuleUnaryOp4846);
+ iv_ruleUnaryOp=ruleUnaryOp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleUnaryOp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleUnaryOp4856); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleUnaryOp"
+
+
+ // $ANTLR start "ruleUnaryOp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2287:1: ruleUnaryOp returns [EObject current=null] : ( ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression ) | ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable ) | (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? ) ) ;
+ public final EObject ruleUnaryOp() throws RecognitionException {
+ EObject current = null;
+
+ Token this_UNARY_0=null;
+ Token this_PLUS_1=null;
+ Token this_MINUS_2=null;
+ Token this_PLUS_PLUS_4=null;
+ Token this_MINUS_MINUS_5=null;
+ Token this_QUESTION_8=null;
+ EObject this_Expression_3 = null;
+
+ EObject this_Variable_6 = null;
+
+ EObject this_Application_7 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2290:28: ( ( ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression ) | ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable ) | (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2291:1: ( ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression ) | ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable ) | (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2291:1: ( ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression ) | ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable ) | (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? ) )
+ int alt41=3;
+ switch ( input.LA(1) ) {
+ case RULE_PLUS:
+ case RULE_MINUS:
+ case RULE_UNARY:
+ {
+ alt41=1;
+ }
+ break;
+ case RULE_PLUS_PLUS:
+ case RULE_MINUS_MINUS:
+ {
+ alt41=2;
+ }
+ break;
+ case RULE_PARAM_START:
+ case RULE_FUNC_ARROW:
+ case RULE_STRING:
+ case RULE_FOR:
+ case RULE_WHILE:
+ case RULE_UNTIL:
+ case RULE_LBRACKET:
+ case RULE_SUPER:
+ case RULE_AT_SIGIL:
+ case RULE_THIS:
+ case RULE_LOOP:
+ case RULE_TRY:
+ case RULE_SWITCH:
+ case RULE_IF:
+ case RULE_IDENTIFIER:
+ case RULE_LCURLY:
+ case RULE_BOUND_FUNC_ARROW:
+ case RULE_NUMBER:
+ case RULE_BOOL:
+ case RULE_JS:
+ case RULE_REGEX:
+ case RULE_LPAREN:
+ {
+ alt41=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 41, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt41) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2291:2: ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2291:2: ( (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2291:3: (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS ) this_Expression_3= ruleExpression
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2291:3: (this_UNARY_0= RULE_UNARY | this_PLUS_1= RULE_PLUS | this_MINUS_2= RULE_MINUS )
+ int alt38=3;
+ switch ( input.LA(1) ) {
+ case RULE_UNARY:
+ {
+ alt38=1;
+ }
+ break;
+ case RULE_PLUS:
+ {
+ alt38=2;
+ }
+ break;
+ case RULE_MINUS:
+ {
+ alt38=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 38, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt38) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2291:4: this_UNARY_0= RULE_UNARY
+ {
+ this_UNARY_0=(Token)match(input,RULE_UNARY,FOLLOW_RULE_UNARY_in_ruleUnaryOp4894); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_UNARY_0, grammarAccess.getUnaryOpAccess().getUNARYTerminalRuleCall_0_0_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2296:6: this_PLUS_1= RULE_PLUS
+ {
+ this_PLUS_1=(Token)match(input,RULE_PLUS,FOLLOW_RULE_PLUS_in_ruleUnaryOp4910); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PLUS_1, grammarAccess.getUnaryOpAccess().getPLUSTerminalRuleCall_0_0_1());
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2301:6: this_MINUS_2= RULE_MINUS
+ {
+ this_MINUS_2=(Token)match(input,RULE_MINUS,FOLLOW_RULE_MINUS_in_ruleUnaryOp4926); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_MINUS_2, grammarAccess.getUnaryOpAccess().getMINUSTerminalRuleCall_0_0_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getExpressionParserRuleCall_0_1());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleUnaryOp4948);
+ this_Expression_3=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Expression_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2315:6: ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2315:6: ( (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2315:7: (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS ) this_Variable_6= ruleVariable
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2315:7: (this_PLUS_PLUS_4= RULE_PLUS_PLUS | this_MINUS_MINUS_5= RULE_MINUS_MINUS )
+ int alt39=2;
+ int LA39_0 = input.LA(1);
+
+ if ( (LA39_0==RULE_PLUS_PLUS) ) {
+ alt39=1;
+ }
+ else if ( (LA39_0==RULE_MINUS_MINUS) ) {
+ alt39=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 39, 0, input);
+
+ throw nvae;
+ }
+ switch (alt39) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2315:8: this_PLUS_PLUS_4= RULE_PLUS_PLUS
+ {
+ this_PLUS_PLUS_4=(Token)match(input,RULE_PLUS_PLUS,FOLLOW_RULE_PLUS_PLUS_in_ruleUnaryOp4967); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PLUS_PLUS_4, grammarAccess.getUnaryOpAccess().getPLUS_PLUSTerminalRuleCall_1_0_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2320:6: this_MINUS_MINUS_5= RULE_MINUS_MINUS
+ {
+ this_MINUS_MINUS_5=(Token)match(input,RULE_MINUS_MINUS,FOLLOW_RULE_MINUS_MINUS_in_ruleUnaryOp4983); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_MINUS_MINUS_5, grammarAccess.getUnaryOpAccess().getMINUS_MINUSTerminalRuleCall_1_0_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getVariableParserRuleCall_1_1());
+
+ }
+ pushFollow(FOLLOW_ruleVariable_in_ruleUnaryOp5005);
+ this_Variable_6=ruleVariable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Variable_6;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2334:6: (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2334:6: (this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2335:5: this_Application_7= ruleApplication (this_QUESTION_8= RULE_QUESTION )?
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getUnaryOpAccess().getApplicationParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleApplication_in_ruleUnaryOp5034);
+ this_Application_7=ruleApplication();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Application_7;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2343:1: (this_QUESTION_8= RULE_QUESTION )?
+ int alt40=2;
+ int LA40_0 = input.LA(1);
+
+ if ( (LA40_0==RULE_QUESTION) ) {
+ alt40=1;
+ }
+ switch (alt40) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2343:2: this_QUESTION_8= RULE_QUESTION
+ {
+ this_QUESTION_8=(Token)match(input,RULE_QUESTION,FOLLOW_RULE_QUESTION_in_ruleUnaryOp5045); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_QUESTION_8, grammarAccess.getUnaryOpAccess().getQUESTIONTerminalRuleCall_2_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleUnaryOp"
+
+
+ // $ANTLR start "entryRuleApplication"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2355:1: entryRuleApplication returns [EObject current=null] : iv_ruleApplication= ruleApplication EOF ;
+ public final EObject entryRuleApplication() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleApplication = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2356:2: (iv_ruleApplication= ruleApplication EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2357:2: iv_ruleApplication= ruleApplication EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getApplicationRule());
+ }
+ pushFollow(FOLLOW_ruleApplication_in_entryRuleApplication5083);
+ iv_ruleApplication=ruleApplication();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleApplication;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleApplication5093); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleApplication"
+
+
+ // $ANTLR start "ruleApplication"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2364:1: ruleApplication returns [EObject current=null] : ( ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) ) | ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* ) ) ;
+ public final EObject ruleApplication() throws RecognitionException {
+ EObject current = null;
+
+ Token this_SUPER_1=null;
+ Token this_CALL_START_2=null;
+ Token this_CALL_END_4=null;
+ EObject lv_args_3_0 = null;
+
+ EObject lv_value_5_0 = null;
+
+ EObject lv_features_6_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2367:28: ( ( ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) ) | ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2368:1: ( ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) ) | ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2368:1: ( ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) ) | ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* ) )
+ int alt44=2;
+ int LA44_0 = input.LA(1);
+
+ if ( (LA44_0==RULE_SUPER) ) {
+ alt44=1;
+ }
+ else if ( (LA44_0==RULE_PARAM_START||LA44_0==RULE_FUNC_ARROW||LA44_0==RULE_STRING||(LA44_0>=RULE_FOR && LA44_0<=RULE_WHILE)||LA44_0==RULE_UNTIL||LA44_0==RULE_LBRACKET||LA44_0==RULE_AT_SIGIL||(LA44_0>=RULE_THIS && LA44_0<=RULE_TRY)||LA44_0==RULE_SWITCH||(LA44_0>=RULE_IF && LA44_0<=RULE_LCURLY)||(LA44_0>=RULE_BOUND_FUNC_ARROW && LA44_0<=RULE_LPAREN)) ) {
+ alt44=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 44, 0, input);
+
+ throw nvae;
+ }
+ switch (alt44) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2368:2: ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2368:2: ( () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2368:3: () (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2368:3: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2369:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getApplicationAccess().getSuperCallAction_0_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2374:2: (this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2374:3: this_SUPER_1= RULE_SUPER (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )?
+ {
+ this_SUPER_1=(Token)match(input,RULE_SUPER,FOLLOW_RULE_SUPER_in_ruleApplication5140); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_SUPER_1, grammarAccess.getApplicationAccess().getSUPERTerminalRuleCall_0_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2378:1: (this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )?
+ int alt42=2;
+ int LA42_0 = input.LA(1);
+
+ if ( (LA42_0==RULE_CALL_START) ) {
+ alt42=1;
+ }
+ switch (alt42) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2378:2: this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END
+ {
+ this_CALL_START_2=(Token)match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_ruleApplication5151); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_START_2, grammarAccess.getApplicationAccess().getCALL_STARTTerminalRuleCall_0_1_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2382:1: ( (lv_args_3_0= ruleArgList ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2383:1: (lv_args_3_0= ruleArgList )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2383:1: (lv_args_3_0= ruleArgList )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2384:3: lv_args_3_0= ruleArgList
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getApplicationAccess().getArgsArgListParserRuleCall_0_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgList_in_ruleApplication5171);
+ lv_args_3_0=ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ set(
+ current,
+ "args",
+ lv_args_3_0,
+ "ArgList");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_CALL_END_4=(Token)match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_ruleApplication5182); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_END_4, grammarAccess.getApplicationAccess().getCALL_ENDTerminalRuleCall_0_1_1_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2405:6: ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2405:6: ( ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2405:7: ( (lv_value_5_0= rulePrimaryExpression ) ) ( (lv_features_6_0= ruleFeatureCall ) )*
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2405:7: ( (lv_value_5_0= rulePrimaryExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2406:1: (lv_value_5_0= rulePrimaryExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2406:1: (lv_value_5_0= rulePrimaryExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2407:3: lv_value_5_0= rulePrimaryExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getApplicationAccess().getValuePrimaryExpressionParserRuleCall_1_0_0());
+
+ }
+ pushFollow(FOLLOW_rulePrimaryExpression_in_ruleApplication5213);
+ lv_value_5_0=rulePrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_5_0,
+ "PrimaryExpression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2423:2: ( (lv_features_6_0= ruleFeatureCall ) )*
+ loop43:
+ do {
+ int alt43=2;
+ int LA43_0 = input.LA(1);
+
+ if ( (LA43_0==RULE_CALL_START||LA43_0==RULE_FUNC_EXIST||(LA43_0>=RULE_DOT && LA43_0<=RULE_INDEX_START)) ) {
+ alt43=1;
+ }
+
+
+ switch (alt43) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2424:1: (lv_features_6_0= ruleFeatureCall )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2424:1: (lv_features_6_0= ruleFeatureCall )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2425:3: lv_features_6_0= ruleFeatureCall
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getApplicationAccess().getFeaturesFeatureCallParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleFeatureCall_in_ruleApplication5234);
+ lv_features_6_0=ruleFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getApplicationRule());
+ }
+ add(
+ current,
+ "features",
+ lv_features_6_0,
+ "FeatureCall");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop43;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleApplication"
+
+
+ // $ANTLR start "entryRuleFeatureCall"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2449:1: entryRuleFeatureCall returns [EObject current=null] : iv_ruleFeatureCall= ruleFeatureCall EOF ;
+ public final EObject entryRuleFeatureCall() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleFeatureCall = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2450:2: (iv_ruleFeatureCall= ruleFeatureCall EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2451:2: iv_ruleFeatureCall= ruleFeatureCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getFeatureCallRule());
+ }
+ pushFollow(FOLLOW_ruleFeatureCall_in_entryRuleFeatureCall5272);
+ iv_ruleFeatureCall=ruleFeatureCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleFeatureCall;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleFeatureCall5282); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleFeatureCall"
+
+
+ // $ANTLR start "ruleFeatureCall"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2458:1: ruleFeatureCall returns [EObject current=null] : (this_FunctionCall_0= ruleFunctionCall | this_PropertyAccess_1= rulePropertyAccess ) ;
+ public final EObject ruleFeatureCall() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_FunctionCall_0 = null;
+
+ EObject this_PropertyAccess_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2461:28: ( (this_FunctionCall_0= ruleFunctionCall | this_PropertyAccess_1= rulePropertyAccess ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2462:1: (this_FunctionCall_0= ruleFunctionCall | this_PropertyAccess_1= rulePropertyAccess )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2462:1: (this_FunctionCall_0= ruleFunctionCall | this_PropertyAccess_1= rulePropertyAccess )
+ int alt45=2;
+ int LA45_0 = input.LA(1);
+
+ if ( (LA45_0==RULE_CALL_START||LA45_0==RULE_FUNC_EXIST) ) {
+ alt45=1;
+ }
+ else if ( ((LA45_0>=RULE_DOT && LA45_0<=RULE_INDEX_START)) ) {
+ alt45=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 45, 0, input);
+
+ throw nvae;
+ }
+ switch (alt45) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2463:5: this_FunctionCall_0= ruleFunctionCall
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleFunctionCall_in_ruleFeatureCall5329);
+ this_FunctionCall_0=ruleFunctionCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_FunctionCall_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2473:5: this_PropertyAccess_1= rulePropertyAccess
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getFeatureCallAccess().getPropertyAccessParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_rulePropertyAccess_in_ruleFeatureCall5356);
+ this_PropertyAccess_1=rulePropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_PropertyAccess_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleFeatureCall"
+
+
+ // $ANTLR start "entryRuleFunctionCall"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2489:1: entryRuleFunctionCall returns [EObject current=null] : iv_ruleFunctionCall= ruleFunctionCall EOF ;
+ public final EObject entryRuleFunctionCall() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleFunctionCall = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2490:2: (iv_ruleFunctionCall= ruleFunctionCall EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2491:2: iv_ruleFunctionCall= ruleFunctionCall EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getFunctionCallRule());
+ }
+ pushFollow(FOLLOW_ruleFunctionCall_in_entryRuleFunctionCall5391);
+ iv_ruleFunctionCall=ruleFunctionCall();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleFunctionCall;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleFunctionCall5401); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleFunctionCall"
+
+
+ // $ANTLR start "ruleFunctionCall"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2498:1: ruleFunctionCall returns [EObject current=null] : ( () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END ) ;
+ public final EObject ruleFunctionCall() throws RecognitionException {
+ EObject current = null;
+
+ Token this_FUNC_EXIST_1=null;
+ Token this_CALL_START_2=null;
+ Token this_CALL_END_4=null;
+ EObject lv_args_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2501:28: ( ( () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2502:1: ( () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2502:1: ( () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2502:2: () (this_FUNC_EXIST_1= RULE_FUNC_EXIST )? this_CALL_START_2= RULE_CALL_START ( (lv_args_3_0= ruleArgList ) ) this_CALL_END_4= RULE_CALL_END
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2502:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2503:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getFunctionCallAccess().getFunctionCallAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2508:2: (this_FUNC_EXIST_1= RULE_FUNC_EXIST )?
+ int alt46=2;
+ int LA46_0 = input.LA(1);
+
+ if ( (LA46_0==RULE_FUNC_EXIST) ) {
+ alt46=1;
+ }
+ switch (alt46) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2508:3: this_FUNC_EXIST_1= RULE_FUNC_EXIST
+ {
+ this_FUNC_EXIST_1=(Token)match(input,RULE_FUNC_EXIST,FOLLOW_RULE_FUNC_EXIST_in_ruleFunctionCall5447); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FUNC_EXIST_1, grammarAccess.getFunctionCallAccess().getFUNC_EXISTTerminalRuleCall_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+ this_CALL_START_2=(Token)match(input,RULE_CALL_START,FOLLOW_RULE_CALL_START_in_ruleFunctionCall5459); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_START_2, grammarAccess.getFunctionCallAccess().getCALL_STARTTerminalRuleCall_2());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2516:1: ( (lv_args_3_0= ruleArgList ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2517:1: (lv_args_3_0= ruleArgList )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2517:1: (lv_args_3_0= ruleArgList )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2518:3: lv_args_3_0= ruleArgList
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getFunctionCallAccess().getArgsArgListParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgList_in_ruleFunctionCall5479);
+ lv_args_3_0=ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getFunctionCallRule());
+ }
+ set(
+ current,
+ "args",
+ lv_args_3_0,
+ "ArgList");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_CALL_END_4=(Token)match(input,RULE_CALL_END,FOLLOW_RULE_CALL_END_in_ruleFunctionCall5490); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CALL_END_4, grammarAccess.getFunctionCallAccess().getCALL_ENDTerminalRuleCall_4());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleFunctionCall"
+
+
+ // $ANTLR start "entryRulePropertyAccess"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2546:1: entryRulePropertyAccess returns [EObject current=null] : iv_rulePropertyAccess= rulePropertyAccess EOF ;
+ public final EObject entryRulePropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_rulePropertyAccess = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2547:2: (iv_rulePropertyAccess= rulePropertyAccess EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2548:2: iv_rulePropertyAccess= rulePropertyAccess EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getPropertyAccessRule());
+ }
+ pushFollow(FOLLOW_rulePropertyAccess_in_entryRulePropertyAccess5525);
+ iv_rulePropertyAccess=rulePropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_rulePropertyAccess;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRulePropertyAccess5535); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRulePropertyAccess"
+
+
+ // $ANTLR start "rulePropertyAccess"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2555:1: rulePropertyAccess returns [EObject current=null] : (this_NamedPropertyAccess_0= ruleNamedPropertyAccess | this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess ) ;
+ public final EObject rulePropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_NamedPropertyAccess_0 = null;
+
+ EObject this_IndexedPropertyAccess_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2558:28: ( (this_NamedPropertyAccess_0= ruleNamedPropertyAccess | this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2559:1: (this_NamedPropertyAccess_0= ruleNamedPropertyAccess | this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2559:1: (this_NamedPropertyAccess_0= ruleNamedPropertyAccess | this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess )
+ int alt47=2;
+ int LA47_0 = input.LA(1);
+
+ if ( ((LA47_0>=RULE_DOT && LA47_0<=RULE_DOUBLE_COLON)) ) {
+ alt47=1;
+ }
+ else if ( (LA47_0==RULE_INDEX_START) ) {
+ alt47=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 47, 0, input);
+
+ throw nvae;
+ }
+ switch (alt47) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2560:5: this_NamedPropertyAccess_0= ruleNamedPropertyAccess
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccessAccess().getNamedPropertyAccessParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleNamedPropertyAccess_in_rulePropertyAccess5582);
+ this_NamedPropertyAccess_0=ruleNamedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_NamedPropertyAccess_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2570:5: this_IndexedPropertyAccess_1= ruleIndexedPropertyAccess
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccessAccess().getIndexedPropertyAccessParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleIndexedPropertyAccess_in_rulePropertyAccess5609);
+ this_IndexedPropertyAccess_1=ruleIndexedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IndexedPropertyAccess_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "rulePropertyAccess"
+
+
+ // $ANTLR start "entryRuleThisProperty"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2586:1: entryRuleThisProperty returns [EObject current=null] : iv_ruleThisProperty= ruleThisProperty EOF ;
+ public final EObject entryRuleThisProperty() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleThisProperty = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2587:2: (iv_ruleThisProperty= ruleThisProperty EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2588:2: iv_ruleThisProperty= ruleThisProperty EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getThisPropertyRule());
+ }
+ pushFollow(FOLLOW_ruleThisProperty_in_entryRuleThisProperty5644);
+ iv_ruleThisProperty=ruleThisProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleThisProperty;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleThisProperty5654); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleThisProperty"
+
+
+ // $ANTLR start "ruleThisProperty"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2595:1: ruleThisProperty returns [EObject current=null] : (this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId ) ;
+ public final EObject ruleThisProperty() throws RecognitionException {
+ EObject current = null;
+
+ Token this_AT_SIGIL_0=null;
+ EObject this_Id_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2598:28: ( (this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2599:1: (this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2599:1: (this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2599:2: this_AT_SIGIL_0= RULE_AT_SIGIL this_Id_1= ruleId
+ {
+ this_AT_SIGIL_0=(Token)match(input,RULE_AT_SIGIL,FOLLOW_RULE_AT_SIGIL_in_ruleThisProperty5690); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_AT_SIGIL_0, grammarAccess.getThisPropertyAccess().getAT_SIGILTerminalRuleCall_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getThisPropertyAccess().getIdParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleThisProperty5711);
+ this_Id_1=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleThisProperty"
+
+
+ // $ANTLR start "entryRuleNamedPropertyAccess"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2620:1: entryRuleNamedPropertyAccess returns [EObject current=null] : iv_ruleNamedPropertyAccess= ruleNamedPropertyAccess EOF ;
+ public final EObject entryRuleNamedPropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleNamedPropertyAccess = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2621:2: (iv_ruleNamedPropertyAccess= ruleNamedPropertyAccess EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2622:2: iv_ruleNamedPropertyAccess= ruleNamedPropertyAccess EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getNamedPropertyAccessRule());
+ }
+ pushFollow(FOLLOW_ruleNamedPropertyAccess_in_entryRuleNamedPropertyAccess5746);
+ iv_ruleNamedPropertyAccess=ruleNamedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleNamedPropertyAccess;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleNamedPropertyAccess5756); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleNamedPropertyAccess"
+
+
+ // $ANTLR start "ruleNamedPropertyAccess"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2629:1: ruleNamedPropertyAccess returns [EObject current=null] : ( ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) ) | ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? ) ) ;
+ public final EObject ruleNamedPropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_accessor_0_1=null;
+ Token lv_accessor_0_2=null;
+ Token lv_accessor_2_0=null;
+ EObject lv_name_1_0 = null;
+
+ EObject lv_name_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2632:28: ( ( ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) ) | ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2633:1: ( ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) ) | ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2633:1: ( ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) ) | ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? ) )
+ int alt50=2;
+ int LA50_0 = input.LA(1);
+
+ if ( ((LA50_0>=RULE_DOT && LA50_0<=RULE_QUESTION_DOT)) ) {
+ alt50=1;
+ }
+ else if ( (LA50_0==RULE_DOUBLE_COLON) ) {
+ alt50=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 50, 0, input);
+
+ throw nvae;
+ }
+ switch (alt50) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2633:2: ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2633:2: ( ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2633:3: ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) ) ( (lv_name_1_0= ruleId ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2633:3: ( ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2634:1: ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2634:1: ( (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2635:1: (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2635:1: (lv_accessor_0_1= RULE_DOT | lv_accessor_0_2= RULE_QUESTION_DOT )
+ int alt48=2;
+ int LA48_0 = input.LA(1);
+
+ if ( (LA48_0==RULE_DOT) ) {
+ alt48=1;
+ }
+ else if ( (LA48_0==RULE_QUESTION_DOT) ) {
+ alt48=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 48, 0, input);
+
+ throw nvae;
+ }
+ switch (alt48) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2636:3: lv_accessor_0_1= RULE_DOT
+ {
+ lv_accessor_0_1=(Token)match(input,RULE_DOT,FOLLOW_RULE_DOT_in_ruleNamedPropertyAccess5801); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_0_1, grammarAccess.getNamedPropertyAccessAccess().getAccessorDOTTerminalRuleCall_0_0_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_0_1,
+ "DOT");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2651:8: lv_accessor_0_2= RULE_QUESTION_DOT
+ {
+ lv_accessor_0_2=(Token)match(input,RULE_QUESTION_DOT,FOLLOW_RULE_QUESTION_DOT_in_ruleNamedPropertyAccess5821); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_0_2, grammarAccess.getNamedPropertyAccessAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_0_2,
+ "QUESTION_DOT");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2669:2: ( (lv_name_1_0= ruleId ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2670:1: (lv_name_1_0= ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2670:1: (lv_name_1_0= ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2671:3: lv_name_1_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleNamedPropertyAccess5850);
+ lv_name_1_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getNamedPropertyAccessRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_1_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2688:6: ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2688:6: ( ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2688:7: ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) ) ( (lv_name_3_0= ruleId ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2688:7: ( (lv_accessor_2_0= RULE_DOUBLE_COLON ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2689:1: (lv_accessor_2_0= RULE_DOUBLE_COLON )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2689:1: (lv_accessor_2_0= RULE_DOUBLE_COLON )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2690:3: lv_accessor_2_0= RULE_DOUBLE_COLON
+ {
+ lv_accessor_2_0=(Token)match(input,RULE_DOUBLE_COLON,FOLLOW_RULE_DOUBLE_COLON_in_ruleNamedPropertyAccess5875); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_2_0, grammarAccess.getNamedPropertyAccessAccess().getAccessorDOUBLE_COLONTerminalRuleCall_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getNamedPropertyAccessRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_2_0,
+ "DOUBLE_COLON");
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2706:2: ( (lv_name_3_0= ruleId ) )?
+ int alt49=2;
+ int LA49_0 = input.LA(1);
+
+ if ( (LA49_0==RULE_IDENTIFIER) ) {
+ alt49=1;
+ }
+ switch (alt49) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2707:1: (lv_name_3_0= ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2707:1: (lv_name_3_0= ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2708:3: lv_name_3_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getNamedPropertyAccessAccess().getNameIdParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleNamedPropertyAccess5901);
+ lv_name_3_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getNamedPropertyAccessRule());
+ }
+ set(
+ current,
+ "name",
+ lv_name_3_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleNamedPropertyAccess"
+
+
+ // $ANTLR start "entryRuleIndexedPropertyAccess"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2732:1: entryRuleIndexedPropertyAccess returns [EObject current=null] : iv_ruleIndexedPropertyAccess= ruleIndexedPropertyAccess EOF ;
+ public final EObject entryRuleIndexedPropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleIndexedPropertyAccess = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2733:2: (iv_ruleIndexedPropertyAccess= ruleIndexedPropertyAccess EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2734:2: iv_ruleIndexedPropertyAccess= ruleIndexedPropertyAccess EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIndexedPropertyAccessRule());
+ }
+ pushFollow(FOLLOW_ruleIndexedPropertyAccess_in_entryRuleIndexedPropertyAccess5939);
+ iv_ruleIndexedPropertyAccess=ruleIndexedPropertyAccess();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleIndexedPropertyAccess;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIndexedPropertyAccess5949); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleIndexedPropertyAccess"
+
+
+ // $ANTLR start "ruleIndexedPropertyAccess"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2741:1: ruleIndexedPropertyAccess returns [EObject current=null] : (this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END ) ;
+ public final EObject ruleIndexedPropertyAccess() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDEX_START_0=null;
+ Token this_INDEX_END_2=null;
+ EObject lv_index_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2744:28: ( (this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2745:1: (this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2745:1: (this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2745:2: this_INDEX_START_0= RULE_INDEX_START ( (lv_index_1_0= ruleIndex ) ) this_INDEX_END_2= RULE_INDEX_END
+ {
+ this_INDEX_START_0=(Token)match(input,RULE_INDEX_START,FOLLOW_RULE_INDEX_START_in_ruleIndexedPropertyAccess5985); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDEX_START_0, grammarAccess.getIndexedPropertyAccessAccess().getINDEX_STARTTerminalRuleCall_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2749:1: ( (lv_index_1_0= ruleIndex ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2750:1: (lv_index_1_0= ruleIndex )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2750:1: (lv_index_1_0= ruleIndex )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2751:3: lv_index_1_0= ruleIndex
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexedPropertyAccessAccess().getIndexIndexParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleIndex_in_ruleIndexedPropertyAccess6005);
+ lv_index_1_0=ruleIndex();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexedPropertyAccessRule());
+ }
+ set(
+ current,
+ "index",
+ lv_index_1_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_INDEX_END_2=(Token)match(input,RULE_INDEX_END,FOLLOW_RULE_INDEX_END_in_ruleIndexedPropertyAccess6016); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDEX_END_2, grammarAccess.getIndexedPropertyAccessAccess().getINDEX_ENDTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleIndexedPropertyAccess"
+
+
+ // $ANTLR start "entryRuleIndex"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2779:1: entryRuleIndex returns [EObject current=null] : iv_ruleIndex= ruleIndex EOF ;
+ public final EObject entryRuleIndex() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleIndex = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2780:2: (iv_ruleIndex= ruleIndex EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2781:2: iv_ruleIndex= ruleIndex EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIndexRule());
+ }
+ pushFollow(FOLLOW_ruleIndex_in_entryRuleIndex6051);
+ iv_ruleIndex=ruleIndex();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleIndex;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIndex6061); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleIndex"
+
+
+ // $ANTLR start "ruleIndex"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2788:1: ruleIndex returns [EObject current=null] : ( ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) ) ;
+ public final EObject ruleIndex() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_dots_0_1=null;
+ Token lv_dots_0_2=null;
+ Token lv_dots_3_1=null;
+ Token lv_dots_3_2=null;
+ EObject lv_end_1_0 = null;
+
+ EObject lv_start_2_0 = null;
+
+ EObject lv_end_4_0 = null;
+
+ EObject lv_exp_5_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2791:28: ( ( ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2792:1: ( ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2792:1: ( ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) )
+ int alt54=3;
+ alt54 = dfa54.predict(input);
+ switch (alt54) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2792:2: ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2792:2: ( ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2792:3: ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2792:3: ( ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2792:4: ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=> ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2803:1: ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2804:1: (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2804:1: (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS )
+ int alt51=2;
+ int LA51_0 = input.LA(1);
+
+ if ( (LA51_0==RULE_DOT_DOT) ) {
+ alt51=1;
+ }
+ else if ( (LA51_0==RULE_ELLIPSIS) ) {
+ alt51=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 51, 0, input);
+
+ throw nvae;
+ }
+ switch (alt51) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2805:3: lv_dots_0_1= RULE_DOT_DOT
+ {
+ lv_dots_0_1=(Token)match(input,RULE_DOT_DOT,FOLLOW_RULE_DOT_DOT_in_ruleIndex6132); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_dots_0_1, grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_0_0_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ current,
+ "dots",
+ lv_dots_0_1,
+ "DOT_DOT");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2820:8: lv_dots_0_2= RULE_ELLIPSIS
+ {
+ lv_dots_0_2=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleIndex6152); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_dots_0_2, grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_0_0_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ current,
+ "dots",
+ lv_dots_0_2,
+ "ELLIPSIS");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2838:2: ( (lv_end_1_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2839:1: (lv_end_1_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2839:1: (lv_end_1_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2840:3: lv_end_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleIndex6181);
+ lv_end_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ current,
+ "end",
+ lv_end_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:6: ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:6: ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:7: ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:7: ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:8: ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2871:6: ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2871:7: ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2871:7: ( (lv_start_2_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2872:1: (lv_start_2_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2872:1: (lv_start_2_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2873:3: lv_start_2_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexAccess().getStartExpressionParserRuleCall_1_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleIndex6251);
+ lv_start_2_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ current,
+ "start",
+ lv_start_2_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2889:2: ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2890:1: ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2890:1: ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2891:1: (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2891:1: (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS )
+ int alt52=2;
+ int LA52_0 = input.LA(1);
+
+ if ( (LA52_0==RULE_DOT_DOT) ) {
+ alt52=1;
+ }
+ else if ( (LA52_0==RULE_ELLIPSIS) ) {
+ alt52=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 52, 0, input);
+
+ throw nvae;
+ }
+ switch (alt52) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2892:3: lv_dots_3_1= RULE_DOT_DOT
+ {
+ lv_dots_3_1=(Token)match(input,RULE_DOT_DOT,FOLLOW_RULE_DOT_DOT_in_ruleIndex6270); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_dots_3_1, grammarAccess.getIndexAccess().getDotsDOT_DOTTerminalRuleCall_1_0_0_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ current,
+ "dots",
+ lv_dots_3_1,
+ "DOT_DOT");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2907:8: lv_dots_3_2= RULE_ELLIPSIS
+ {
+ lv_dots_3_2=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleIndex6290); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_dots_3_2, grammarAccess.getIndexAccess().getDotsELLIPSISTerminalRuleCall_1_0_0_1_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIndexRule());
+ }
+ setWithLastConsumed(
+ current,
+ "dots",
+ lv_dots_3_2,
+ "ELLIPSIS");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2925:4: ( (lv_end_4_0= ruleExpression ) )?
+ int alt53=2;
+ int LA53_0 = input.LA(1);
+
+ if ( (LA53_0==RULE_PARAM_START||LA53_0==RULE_FUNC_ARROW||LA53_0==RULE_STRING||(LA53_0>=RULE_FOR && LA53_0<=RULE_WHILE)||LA53_0==RULE_UNTIL||LA53_0==RULE_LBRACKET||(LA53_0>=RULE_PLUS && LA53_0<=RULE_MINUS)||(LA53_0>=RULE_UNARY && LA53_0<=RULE_MINUS_MINUS)||LA53_0==RULE_SUPER||LA53_0==RULE_AT_SIGIL||(LA53_0>=RULE_THIS && LA53_0<=RULE_TRY)||LA53_0==RULE_SWITCH||(LA53_0>=RULE_IF && LA53_0<=RULE_LCURLY)||(LA53_0>=RULE_BOUND_FUNC_ARROW && LA53_0<=RULE_LPAREN)) ) {
+ alt53=1;
+ }
+ switch (alt53) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2926:1: (lv_end_4_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2926:1: (lv_end_4_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2927:3: lv_end_4_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexAccess().getEndExpressionParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleIndex6321);
+ lv_end_4_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ current,
+ "end",
+ lv_end_4_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2944:6: ( (lv_exp_5_0= ruleExpression ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2944:6: ( (lv_exp_5_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2945:1: (lv_exp_5_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2945:1: (lv_exp_5_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2946:3: lv_exp_5_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIndexAccess().getExpExpressionParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleIndex6350);
+ lv_exp_5_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIndexRule());
+ }
+ set(
+ current,
+ "exp",
+ lv_exp_5_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleIndex"
+
+
+ // $ANTLR start "entryRulePrimaryExpression"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2970:1: entryRulePrimaryExpression returns [EObject current=null] : iv_rulePrimaryExpression= rulePrimaryExpression EOF ;
+ public final EObject entryRulePrimaryExpression() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_rulePrimaryExpression = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2971:2: (iv_rulePrimaryExpression= rulePrimaryExpression EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2972:2: iv_rulePrimaryExpression= rulePrimaryExpression EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getPrimaryExpressionRule());
+ }
+ pushFollow(FOLLOW_rulePrimaryExpression_in_entryRulePrimaryExpression6386);
+ iv_rulePrimaryExpression=rulePrimaryExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_rulePrimaryExpression;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRulePrimaryExpression6396); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRulePrimaryExpression"
+
+
+ // $ANTLR start "rulePrimaryExpression"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2979:1: rulePrimaryExpression returns [EObject current=null] : (this_IfExp_0= ruleIfExp | this_Parenthetical_1= ruleParenthetical | this_Literal_2= ruleLiteral | ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef ) ;
+ public final EObject rulePrimaryExpression() throws RecognitionException {
+ EObject current = null;
+
+ Token this_THIS_9=null;
+ Token this_FOR_11=null;
+ Token this_WHILE_15=null;
+ Token this_WHEN_17=null;
+ Token this_UNTIL_21=null;
+ Token this_WHEN_23=null;
+ Token this_LOOP_27=null;
+ Token this_TRY_30=null;
+ Token this_CATCH_32=null;
+ Token this_FINALLY_35=null;
+ Token this_FINALLY_37=null;
+ Token this_SWITCH_40=null;
+ Token this_INDENT_42=null;
+ Token this_ELSE_44=null;
+ Token this_OUTDENT_46=null;
+ EObject this_IfExp_0 = null;
+
+ EObject this_Parenthetical_1 = null;
+
+ EObject this_Literal_2 = null;
+
+ EObject this_Range_3 = null;
+
+ EObject this_Array_4 = null;
+
+ EObject this_Dictionary_5 = null;
+
+ EObject this_Lambda_6 = null;
+
+ EObject this_ThisProperty_7 = null;
+
+ EObject lv_loop_12_0 = null;
+
+ EObject lv_body_13_0 = null;
+
+ EObject lv_loop_16_0 = null;
+
+ EObject lv_when_18_0 = null;
+
+ EObject lv_body_19_0 = null;
+
+ EObject lv_loop_22_0 = null;
+
+ EObject lv_when_24_0 = null;
+
+ EObject lv_body_25_0 = null;
+
+ EObject lv_body_28_0 = null;
+
+ EObject lv_body_31_0 = null;
+
+ EObject lv_exception_33_0 = null;
+
+ EObject lv_catchBlock_34_0 = null;
+
+ EObject lv_finallyBlock_36_0 = null;
+
+ EObject lv_finallyBlock_38_0 = null;
+
+ EObject lv_exp_41_0 = null;
+
+ EObject lv_cases_43_0 = null;
+
+ EObject lv_elseBlock_45_0 = null;
+
+ EObject this_IdRef_47 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2982:28: ( (this_IfExp_0= ruleIfExp | this_Parenthetical_1= ruleParenthetical | this_Literal_2= ruleLiteral | ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2983:1: (this_IfExp_0= ruleIfExp | this_Parenthetical_1= ruleParenthetical | this_Literal_2= ruleLiteral | ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2983:1: (this_IfExp_0= ruleIfExp | this_Parenthetical_1= ruleParenthetical | this_Literal_2= ruleLiteral | ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef )
+ int alt62=16;
+ alt62 = dfa62.predict(input);
+ switch (alt62) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2984:5: this_IfExp_0= ruleIfExp
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getIfExpParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleIfExp_in_rulePrimaryExpression6443);
+ this_IfExp_0=ruleIfExp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IfExp_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2994:5: this_Parenthetical_1= ruleParenthetical
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getParentheticalParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleParenthetical_in_rulePrimaryExpression6470);
+ this_Parenthetical_1=ruleParenthetical();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Parenthetical_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3004:5: this_Literal_2= ruleLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleLiteral_in_rulePrimaryExpression6497);
+ this_Literal_2=ruleLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Literal_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3013:6: ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3013:6: ( ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3013:7: ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )=>this_Range_3= ruleRange
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getRangeParserRuleCall_3());
+
+ }
+ pushFollow(FOLLOW_ruleRange_in_rulePrimaryExpression6553);
+ this_Range_3=ruleRange();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Range_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3028:6: ( ( RULE_LBRACKET )=>this_Array_4= ruleArray )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3028:6: ( ( RULE_LBRACKET )=>this_Array_4= ruleArray )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3028:7: ( RULE_LBRACKET )=>this_Array_4= ruleArray
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getArrayParserRuleCall_4());
+
+ }
+ pushFollow(FOLLOW_ruleArray_in_rulePrimaryExpression6587);
+ this_Array_4=ruleArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Array_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 6 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3038:6: ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3038:6: ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3038:7: ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getDictionaryParserRuleCall_5());
+
+ }
+ pushFollow(FOLLOW_ruleDictionary_in_rulePrimaryExpression6621);
+ this_Dictionary_5=ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Dictionary_5;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 7 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3049:5: this_Lambda_6= ruleLambda
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLambdaParserRuleCall_6());
+
+ }
+ pushFollow(FOLLOW_ruleLambda_in_rulePrimaryExpression6649);
+ this_Lambda_6=ruleLambda();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Lambda_6;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 8 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3059:5: this_ThisProperty_7= ruleThisProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getThisPropertyParserRuleCall_7());
+
+ }
+ pushFollow(FOLLOW_ruleThisProperty_in_rulePrimaryExpression6676);
+ this_ThisProperty_7=ruleThisProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ThisProperty_7;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 9 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3068:6: ( () this_THIS_9= RULE_THIS )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3068:6: ( () this_THIS_9= RULE_THIS )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3068:7: () this_THIS_9= RULE_THIS
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3068:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3069:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getThisAloneAction_8_0(),
+ current);
+
+ }
+
+ }
+
+ this_THIS_9=(Token)match(input,RULE_THIS,FOLLOW_RULE_THIS_in_rulePrimaryExpression6702); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_THIS_9, grammarAccess.getPrimaryExpressionAccess().getTHISTerminalRuleCall_8_1());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 10 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3079:6: ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3079:6: ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3079:7: () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3079:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3080:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getForAction_9_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3085:2: (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3085:3: this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) )
+ {
+ this_FOR_11=(Token)match(input,RULE_FOR,FOLLOW_RULE_FOR_in_rulePrimaryExpression6730); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FOR_11, grammarAccess.getPrimaryExpressionAccess().getFORTerminalRuleCall_9_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3089:1: ( (lv_loop_12_0= ruleForBody ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3090:1: (lv_loop_12_0= ruleForBody )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3090:1: (lv_loop_12_0= ruleForBody )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3091:3: lv_loop_12_0= ruleForBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopForBodyParserRuleCall_9_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleForBody_in_rulePrimaryExpression6750);
+ lv_loop_12_0=ruleForBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "loop",
+ lv_loop_12_0,
+ "ForBody");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3107:2: ( (lv_body_13_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3108:1: (lv_body_13_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3108:1: (lv_body_13_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3109:3: lv_body_13_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_9_1_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6771);
+ lv_body_13_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_13_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 11 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3126:6: ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3126:6: ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3126:7: () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3126:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3127:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getWhileAction_10_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3132:2: (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3132:3: this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) )
+ {
+ this_WHILE_15=(Token)match(input,RULE_WHILE,FOLLOW_RULE_WHILE_in_rulePrimaryExpression6801); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHILE_15, grammarAccess.getPrimaryExpressionAccess().getWHILETerminalRuleCall_10_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3136:1: ( (lv_loop_16_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3137:1: (lv_loop_16_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3137:1: (lv_loop_16_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3138:3: lv_loop_16_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_10_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression6821);
+ lv_loop_16_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "loop",
+ lv_loop_16_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3154:2: (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )?
+ int alt55=2;
+ int LA55_0 = input.LA(1);
+
+ if ( (LA55_0==RULE_WHEN) ) {
+ alt55=1;
+ }
+ switch (alt55) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3154:3: this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) )
+ {
+ this_WHEN_17=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rulePrimaryExpression6833); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_17, grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_10_1_2_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3158:1: ( (lv_when_18_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3159:1: (lv_when_18_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3159:1: (lv_when_18_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3160:3: lv_when_18_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_10_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression6853);
+ lv_when_18_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_18_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3176:4: ( (lv_body_19_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3177:1: (lv_body_19_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3177:1: (lv_body_19_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3178:3: lv_body_19_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_10_1_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6876);
+ lv_body_19_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_19_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 12 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3195:6: ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3195:6: ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3195:7: () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3195:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3196:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getUntilAction_11_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3201:2: (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3201:3: this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) )
+ {
+ this_UNTIL_21=(Token)match(input,RULE_UNTIL,FOLLOW_RULE_UNTIL_in_rulePrimaryExpression6906); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_UNTIL_21, grammarAccess.getPrimaryExpressionAccess().getUNTILTerminalRuleCall_11_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3205:1: ( (lv_loop_22_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3206:1: (lv_loop_22_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3206:1: (lv_loop_22_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3207:3: lv_loop_22_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getLoopExpressionParserRuleCall_11_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression6926);
+ lv_loop_22_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "loop",
+ lv_loop_22_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3223:2: (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )?
+ int alt56=2;
+ int LA56_0 = input.LA(1);
+
+ if ( (LA56_0==RULE_WHEN) ) {
+ alt56=1;
+ }
+ switch (alt56) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3223:3: this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) )
+ {
+ this_WHEN_23=(Token)match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_rulePrimaryExpression6938); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_WHEN_23, grammarAccess.getPrimaryExpressionAccess().getWHENTerminalRuleCall_11_1_2_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3227:1: ( (lv_when_24_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3228:1: (lv_when_24_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3228:1: (lv_when_24_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3229:3: lv_when_24_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getWhenExpressionParserRuleCall_11_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression6958);
+ lv_when_24_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "when",
+ lv_when_24_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3245:4: ( (lv_body_25_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3246:1: (lv_body_25_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3246:1: (lv_body_25_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3247:3: lv_body_25_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_11_1_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression6981);
+ lv_body_25_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_25_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 13 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3264:6: ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3264:6: ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3264:7: () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3264:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3265:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getLoopAction_12_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3270:2: (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3270:3: this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) )
+ {
+ this_LOOP_27=(Token)match(input,RULE_LOOP,FOLLOW_RULE_LOOP_in_rulePrimaryExpression7011); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LOOP_27, grammarAccess.getPrimaryExpressionAccess().getLOOPTerminalRuleCall_12_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3274:1: ( (lv_body_28_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3275:1: (lv_body_28_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3275:1: (lv_body_28_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3276:3: lv_body_28_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_12_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression7031);
+ lv_body_28_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_28_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 14 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3293:6: ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3293:6: ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3293:7: () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3293:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3294:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getTryCatchAction_13_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3299:2: (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3299:3: this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )?
+ {
+ this_TRY_30=(Token)match(input,RULE_TRY,FOLLOW_RULE_TRY_in_rulePrimaryExpression7061); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TRY_30, grammarAccess.getPrimaryExpressionAccess().getTRYTerminalRuleCall_13_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3303:1: ( (lv_body_31_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3304:1: (lv_body_31_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3304:1: (lv_body_31_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3305:3: lv_body_31_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getBodyBlockParserRuleCall_13_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression7081);
+ lv_body_31_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_31_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3321:2: ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )?
+ int alt58=3;
+ int LA58_0 = input.LA(1);
+
+ if ( (LA58_0==RULE_CATCH) ) {
+ alt58=1;
+ }
+ else if ( (LA58_0==RULE_FINALLY) ) {
+ alt58=2;
+ }
+ switch (alt58) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3321:3: (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3321:3: (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3321:4: this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )?
+ {
+ this_CATCH_32=(Token)match(input,RULE_CATCH,FOLLOW_RULE_CATCH_in_rulePrimaryExpression7094); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_CATCH_32, grammarAccess.getPrimaryExpressionAccess().getCATCHTerminalRuleCall_13_1_2_0_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3325:1: ( (lv_exception_33_0= ruleId ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3326:1: (lv_exception_33_0= ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3326:1: (lv_exception_33_0= ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3327:3: lv_exception_33_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getExceptionIdParserRuleCall_13_1_2_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_rulePrimaryExpression7114);
+ lv_exception_33_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "exception",
+ lv_exception_33_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3343:2: ( (lv_catchBlock_34_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3344:1: (lv_catchBlock_34_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3344:1: (lv_catchBlock_34_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3345:3: lv_catchBlock_34_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getCatchBlockBlockParserRuleCall_13_1_2_0_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression7135);
+ lv_catchBlock_34_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "catchBlock",
+ lv_catchBlock_34_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3361:2: (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )?
+ int alt57=2;
+ int LA57_0 = input.LA(1);
+
+ if ( (LA57_0==RULE_FINALLY) ) {
+ alt57=1;
+ }
+ switch (alt57) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3361:3: this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) )
+ {
+ this_FINALLY_35=(Token)match(input,RULE_FINALLY,FOLLOW_RULE_FINALLY_in_rulePrimaryExpression7147); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FINALLY_35, grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_0_3_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3365:1: ( (lv_finallyBlock_36_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3366:1: (lv_finallyBlock_36_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3366:1: (lv_finallyBlock_36_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3367:3: lv_finallyBlock_36_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_0_3_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression7167);
+ lv_finallyBlock_36_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "finallyBlock",
+ lv_finallyBlock_36_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3384:6: (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3384:6: (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3384:7: this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) )
+ {
+ this_FINALLY_37=(Token)match(input,RULE_FINALLY,FOLLOW_RULE_FINALLY_in_rulePrimaryExpression7188); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FINALLY_37, grammarAccess.getPrimaryExpressionAccess().getFINALLYTerminalRuleCall_13_1_2_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3388:1: ( (lv_finallyBlock_38_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3389:1: (lv_finallyBlock_38_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3389:1: (lv_finallyBlock_38_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3390:3: lv_finallyBlock_38_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getFinallyBlockBlockParserRuleCall_13_1_2_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression7208);
+ lv_finallyBlock_38_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "finallyBlock",
+ lv_finallyBlock_38_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 15 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3407:6: ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3407:6: ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3407:7: () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3407:7: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3408:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getPrimaryExpressionAccess().getSwitchAction_14_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3413:2: (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3413:3: this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT
+ {
+ this_SWITCH_40=(Token)match(input,RULE_SWITCH,FOLLOW_RULE_SWITCH_in_rulePrimaryExpression7241); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_SWITCH_40, grammarAccess.getPrimaryExpressionAccess().getSWITCHTerminalRuleCall_14_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3417:1: ( (lv_exp_41_0= ruleExpression ) )?
+ int alt59=2;
+ int LA59_0 = input.LA(1);
+
+ if ( (LA59_0==RULE_PARAM_START||LA59_0==RULE_FUNC_ARROW||LA59_0==RULE_STRING||(LA59_0>=RULE_FOR && LA59_0<=RULE_WHILE)||LA59_0==RULE_UNTIL||LA59_0==RULE_LBRACKET||(LA59_0>=RULE_PLUS && LA59_0<=RULE_MINUS)||(LA59_0>=RULE_UNARY && LA59_0<=RULE_MINUS_MINUS)||LA59_0==RULE_SUPER||LA59_0==RULE_AT_SIGIL||(LA59_0>=RULE_THIS && LA59_0<=RULE_TRY)||LA59_0==RULE_SWITCH||(LA59_0>=RULE_IF && LA59_0<=RULE_LCURLY)||(LA59_0>=RULE_BOUND_FUNC_ARROW && LA59_0<=RULE_LPAREN)) ) {
+ alt59=1;
+ }
+ switch (alt59) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3418:1: (lv_exp_41_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3418:1: (lv_exp_41_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3419:3: lv_exp_41_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getExpExpressionParserRuleCall_14_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_rulePrimaryExpression7261);
+ lv_exp_41_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "exp",
+ lv_exp_41_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ this_INDENT_42=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_rulePrimaryExpression7273); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_42, grammarAccess.getPrimaryExpressionAccess().getINDENTTerminalRuleCall_14_1_2());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3439:1: ( (lv_cases_43_0= ruleCase ) )*
+ loop60:
+ do {
+ int alt60=2;
+ int LA60_0 = input.LA(1);
+
+ if ( (LA60_0==RULE_LEADING_WHEN) ) {
+ alt60=1;
+ }
+
+
+ switch (alt60) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3440:1: (lv_cases_43_0= ruleCase )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3440:1: (lv_cases_43_0= ruleCase )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3441:3: lv_cases_43_0= ruleCase
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_14_1_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleCase_in_rulePrimaryExpression7293);
+ lv_cases_43_0=ruleCase();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ add(
+ current,
+ "cases",
+ lv_cases_43_0,
+ "Case");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop60;
+ }
+ } while (true);
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3457:3: (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )?
+ int alt61=2;
+ int LA61_0 = input.LA(1);
+
+ if ( (LA61_0==RULE_ELSE) ) {
+ alt61=1;
+ }
+ switch (alt61) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3457:4: this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) )
+ {
+ this_ELSE_44=(Token)match(input,RULE_ELSE,FOLLOW_RULE_ELSE_in_rulePrimaryExpression7306); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_ELSE_44, grammarAccess.getPrimaryExpressionAccess().getELSETerminalRuleCall_14_1_4_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3461:1: ( (lv_elseBlock_45_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3462:1: (lv_elseBlock_45_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3462:1: (lv_elseBlock_45_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3463:3: lv_elseBlock_45_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getElseBlockBlockParserRuleCall_14_1_4_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_rulePrimaryExpression7326);
+ lv_elseBlock_45_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPrimaryExpressionRule());
+ }
+ set(
+ current,
+ "elseBlock",
+ lv_elseBlock_45_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ this_OUTDENT_46=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_rulePrimaryExpression7339); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_46, grammarAccess.getPrimaryExpressionAccess().getOUTDENTTerminalRuleCall_14_1_5());
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 16 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3485:5: this_IdRef_47= ruleIdRef
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPrimaryExpressionAccess().getIdRefParserRuleCall_15());
+
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_rulePrimaryExpression7368);
+ this_IdRef_47=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IdRef_47;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "rulePrimaryExpression"
+
+
+ // $ANTLR start "entryRuleBlock"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3501:1: entryRuleBlock returns [EObject current=null] : iv_ruleBlock= ruleBlock EOF ;
+ public final EObject entryRuleBlock() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleBlock = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3502:2: (iv_ruleBlock= ruleBlock EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3503:2: iv_ruleBlock= ruleBlock EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getBlockRule());
+ }
+ pushFollow(FOLLOW_ruleBlock_in_entryRuleBlock7403);
+ iv_ruleBlock=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleBlock;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBlock7413); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleBlock"
+
+
+ // $ANTLR start "ruleBlock"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3510:1: ruleBlock returns [EObject current=null] : ( () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT ) ;
+ public final EObject ruleBlock() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDENT_1=null;
+ Token this_OUTDENT_3=null;
+ EObject this_Body_2 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3513:28: ( ( () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3514:1: ( () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3514:1: ( () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3514:2: () this_INDENT_1= RULE_INDENT (this_Body_2= ruleBody )? this_OUTDENT_3= RULE_OUTDENT
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3514:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3515:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getBlockAccess().getBlockAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_INDENT_1=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleBlock7458); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_1, grammarAccess.getBlockAccess().getINDENTTerminalRuleCall_1());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3524:1: (this_Body_2= ruleBody )?
+ int alt63=2;
+ int LA63_0 = input.LA(1);
+
+ if ( (LA63_0==RULE_PARAM_START||LA63_0==RULE_FUNC_ARROW||(LA63_0>=RULE_STATEMENT && LA63_0<=RULE_HERECOMMENT)||(LA63_0>=RULE_STRING && LA63_0<=RULE_RETURN)||(LA63_0>=RULE_THROW && LA63_0<=RULE_CLASS)||(LA63_0>=RULE_FOR && LA63_0<=RULE_WHILE)||LA63_0==RULE_UNTIL||LA63_0==RULE_LBRACKET||(LA63_0>=RULE_PLUS && LA63_0<=RULE_MINUS)||(LA63_0>=RULE_UNARY && LA63_0<=RULE_MINUS_MINUS)||LA63_0==RULE_SUPER||LA63_0==RULE_AT_SIGIL||(LA63_0>=RULE_THIS && LA63_0<=RULE_TRY)||LA63_0==RULE_SWITCH||(LA63_0>=RULE_IF && LA63_0<=RULE_LCURLY)||(LA63_0>=RULE_BOUND_FUNC_ARROW && LA63_0<=RULE_LPAREN)) ) {
+ alt63=1;
+ }
+ switch (alt63) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3525:5: this_Body_2= ruleBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getBlockAccess().getBodyParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleBody_in_ruleBlock7480);
+ this_Body_2=ruleBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Body_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+ this_OUTDENT_3=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleBlock7492); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_3, grammarAccess.getBlockAccess().getOUTDENTTerminalRuleCall_3());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleBlock"
+
+
+ // $ANTLR start "entryRuleCase"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3545:1: entryRuleCase returns [EObject current=null] : iv_ruleCase= ruleCase EOF ;
+ public final EObject entryRuleCase() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleCase = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3546:2: (iv_ruleCase= ruleCase EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3547:2: iv_ruleCase= ruleCase EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getCaseRule());
+ }
+ pushFollow(FOLLOW_ruleCase_in_entryRuleCase7527);
+ iv_ruleCase=ruleCase();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleCase;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCase7537); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleCase"
+
+
+ // $ANTLR start "ruleCase"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3554:1: ruleCase returns [EObject current=null] : (this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )? ) ;
+ public final EObject ruleCase() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LEADING_WHEN_0=null;
+ Token this_COMMA_2=null;
+ Token this_TERMINATOR_5=null;
+ EObject lv_whens_1_0 = null;
+
+ EObject lv_whens_3_0 = null;
+
+ EObject lv_then_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3557:28: ( (this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3558:1: (this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3558:1: (this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3558:2: this_LEADING_WHEN_0= RULE_LEADING_WHEN ( (lv_whens_1_0= ruleExpression ) ) (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )* ( (lv_then_4_0= ruleBlock ) ) (this_TERMINATOR_5= RULE_TERMINATOR )?
+ {
+ this_LEADING_WHEN_0=(Token)match(input,RULE_LEADING_WHEN,FOLLOW_RULE_LEADING_WHEN_in_ruleCase7573); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LEADING_WHEN_0, grammarAccess.getCaseAccess().getLEADING_WHENTerminalRuleCall_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3562:1: ( (lv_whens_1_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3563:1: (lv_whens_1_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3563:1: (lv_whens_1_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3564:3: lv_whens_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleCase7593);
+ lv_whens_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ add(
+ current,
+ "whens",
+ lv_whens_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3580:2: (this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) ) )*
+ loop64:
+ do {
+ int alt64=2;
+ int LA64_0 = input.LA(1);
+
+ if ( (LA64_0==RULE_COMMA) ) {
+ alt64=1;
+ }
+
+
+ switch (alt64) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3580:3: this_COMMA_2= RULE_COMMA ( (lv_whens_3_0= ruleExpression ) )
+ {
+ this_COMMA_2=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleCase7605); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_2, grammarAccess.getCaseAccess().getCOMMATerminalRuleCall_2_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3584:1: ( (lv_whens_3_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3585:1: (lv_whens_3_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3585:1: (lv_whens_3_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3586:3: lv_whens_3_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCaseAccess().getWhensExpressionParserRuleCall_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleCase7625);
+ lv_whens_3_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ add(
+ current,
+ "whens",
+ lv_whens_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop64;
+ }
+ } while (true);
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3602:4: ( (lv_then_4_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3603:1: (lv_then_4_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3603:1: (lv_then_4_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3604:3: lv_then_4_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCaseAccess().getThenBlockParserRuleCall_3_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleCase7648);
+ lv_then_4_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCaseRule());
+ }
+ set(
+ current,
+ "then",
+ lv_then_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3620:2: (this_TERMINATOR_5= RULE_TERMINATOR )?
+ int alt65=2;
+ int LA65_0 = input.LA(1);
+
+ if ( (LA65_0==RULE_TERMINATOR) ) {
+ alt65=1;
+ }
+ switch (alt65) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3620:3: this_TERMINATOR_5= RULE_TERMINATOR
+ {
+ this_TERMINATOR_5=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleCase7660); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_5, grammarAccess.getCaseAccess().getTERMINATORTerminalRuleCall_4());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleCase"
+
+
+ // $ANTLR start "entryRuleIfExp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3632:1: entryRuleIfExp returns [EObject current=null] : iv_ruleIfExp= ruleIfExp EOF ;
+ public final EObject entryRuleIfExp() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleIfExp = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3633:2: (iv_ruleIfExp= ruleIfExp EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3634:2: iv_ruleIfExp= ruleIfExp EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIfExpRule());
+ }
+ pushFollow(FOLLOW_ruleIfExp_in_entryRuleIfExp7697);
+ iv_ruleIfExp=ruleIfExp();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleIfExp;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIfExp7707); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleIfExp"
+
+
+ // $ANTLR start "ruleIfExp"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3641:1: ruleIfExp returns [EObject current=null] : ( ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )? ) ;
+ public final EObject ruleIfExp() throws RecognitionException {
+ EObject current = null;
+
+ Token this_ELSE_1=null;
+ Token this_ELSE_3=null;
+ EObject lv_blocks_0_0 = null;
+
+ EObject lv_blocks_2_0 = null;
+
+ EObject lv_defaultBlock_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3644:28: ( ( ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3645:1: ( ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3645:1: ( ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3645:2: ( (lv_blocks_0_0= ruleCondBlock ) ) (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )* (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3645:2: ( (lv_blocks_0_0= ruleCondBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3646:1: (lv_blocks_0_0= ruleCondBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3646:1: (lv_blocks_0_0= ruleCondBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3647:3: lv_blocks_0_0= ruleCondBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleCondBlock_in_ruleIfExp7753);
+ lv_blocks_0_0=ruleCondBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ add(
+ current,
+ "blocks",
+ lv_blocks_0_0,
+ "CondBlock");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3663:2: (this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) ) )*
+ loop66:
+ do {
+ int alt66=2;
+ int LA66_0 = input.LA(1);
+
+ if ( (LA66_0==RULE_ELSE) ) {
+ int LA66_1 = input.LA(2);
+
+ if ( (LA66_1==RULE_IF) ) {
+ alt66=1;
+ }
+
+
+ }
+
+
+ switch (alt66) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3663:3: this_ELSE_1= RULE_ELSE ( (lv_blocks_2_0= ruleCondBlock ) )
+ {
+ this_ELSE_1=(Token)match(input,RULE_ELSE,FOLLOW_RULE_ELSE_in_ruleIfExp7765); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_ELSE_1, grammarAccess.getIfExpAccess().getELSETerminalRuleCall_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3667:1: ( (lv_blocks_2_0= ruleCondBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3668:1: (lv_blocks_2_0= ruleCondBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3668:1: (lv_blocks_2_0= ruleCondBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3669:3: lv_blocks_2_0= ruleCondBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIfExpAccess().getBlocksCondBlockParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleCondBlock_in_ruleIfExp7785);
+ lv_blocks_2_0=ruleCondBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ add(
+ current,
+ "blocks",
+ lv_blocks_2_0,
+ "CondBlock");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop66;
+ }
+ } while (true);
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3685:4: (this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) ) )?
+ int alt67=2;
+ int LA67_0 = input.LA(1);
+
+ if ( (LA67_0==RULE_ELSE) ) {
+ alt67=1;
+ }
+ switch (alt67) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3685:5: this_ELSE_3= RULE_ELSE ( (lv_defaultBlock_4_0= ruleBlock ) )
+ {
+ this_ELSE_3=(Token)match(input,RULE_ELSE,FOLLOW_RULE_ELSE_in_ruleIfExp7799); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_ELSE_3, grammarAccess.getIfExpAccess().getELSETerminalRuleCall_2_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3689:1: ( (lv_defaultBlock_4_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3690:1: (lv_defaultBlock_4_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3690:1: (lv_defaultBlock_4_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3691:3: lv_defaultBlock_4_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getIfExpAccess().getDefaultBlockBlockParserRuleCall_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleIfExp7819);
+ lv_defaultBlock_4_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getIfExpRule());
+ }
+ set(
+ current,
+ "defaultBlock",
+ lv_defaultBlock_4_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleIfExp"
+
+
+ // $ANTLR start "entryRuleCondBlock"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3715:1: entryRuleCondBlock returns [EObject current=null] : iv_ruleCondBlock= ruleCondBlock EOF ;
+ public final EObject entryRuleCondBlock() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleCondBlock = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3716:2: (iv_ruleCondBlock= ruleCondBlock EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3717:2: iv_ruleCondBlock= ruleCondBlock EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getCondBlockRule());
+ }
+ pushFollow(FOLLOW_ruleCondBlock_in_entryRuleCondBlock7857);
+ iv_ruleCondBlock=ruleCondBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleCondBlock;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleCondBlock7867); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleCondBlock"
+
+
+ // $ANTLR start "ruleCondBlock"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3724:1: ruleCondBlock returns [EObject current=null] : ( ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) ) ) ;
+ public final EObject ruleCondBlock() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_operator_0_0=null;
+ EObject lv_condition_1_0 = null;
+
+ EObject lv_action_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3727:28: ( ( ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3728:1: ( ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3728:1: ( ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3728:2: ( (lv_operator_0_0= RULE_IF ) ) ( (lv_condition_1_0= ruleExpression ) ) ( (lv_action_2_0= ruleBlock ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3728:2: ( (lv_operator_0_0= RULE_IF ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3729:1: (lv_operator_0_0= RULE_IF )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3729:1: (lv_operator_0_0= RULE_IF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3730:3: lv_operator_0_0= RULE_IF
+ {
+ lv_operator_0_0=(Token)match(input,RULE_IF,FOLLOW_RULE_IF_in_ruleCondBlock7909); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_operator_0_0, grammarAccess.getCondBlockAccess().getOperatorIFTerminalRuleCall_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getCondBlockRule());
+ }
+ setWithLastConsumed(
+ current,
+ "operator",
+ lv_operator_0_0,
+ "IF");
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3746:2: ( (lv_condition_1_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3747:1: (lv_condition_1_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3747:1: (lv_condition_1_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3748:3: lv_condition_1_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCondBlockAccess().getConditionExpressionParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleCondBlock7935);
+ lv_condition_1_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCondBlockRule());
+ }
+ set(
+ current,
+ "condition",
+ lv_condition_1_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3764:2: ( (lv_action_2_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3765:1: (lv_action_2_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3765:1: (lv_action_2_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3766:3: lv_action_2_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleCondBlock7956);
+ lv_action_2_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getCondBlockRule());
+ }
+ set(
+ current,
+ "action",
+ lv_action_2_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleCondBlock"
+
+
+ // $ANTLR start "entryRuleIdRef"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3790:1: entryRuleIdRef returns [EObject current=null] : iv_ruleIdRef= ruleIdRef EOF ;
+ public final EObject entryRuleIdRef() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleIdRef = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3791:2: (iv_ruleIdRef= ruleIdRef EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3792:2: iv_ruleIdRef= ruleIdRef EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIdRefRule());
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_entryRuleIdRef7992);
+ iv_ruleIdRef=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleIdRef;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleIdRef8002); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleIdRef"
+
+
+ // $ANTLR start "ruleIdRef"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3799:1: ruleIdRef returns [EObject current=null] : ( (otherlv_0= RULE_IDENTIFIER ) ) ;
+ public final EObject ruleIdRef() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3802:28: ( ( (otherlv_0= RULE_IDENTIFIER ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3803:1: ( (otherlv_0= RULE_IDENTIFIER ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3803:1: ( (otherlv_0= RULE_IDENTIFIER ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3804:1: (otherlv_0= RULE_IDENTIFIER )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3804:1: (otherlv_0= RULE_IDENTIFIER )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3805:3: otherlv_0= RULE_IDENTIFIER
+ {
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIdRefRule());
+ }
+
+ }
+ otherlv_0=(Token)match(input,RULE_IDENTIFIER,FOLLOW_RULE_IDENTIFIER_in_ruleIdRef8046); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(otherlv_0, grammarAccess.getIdRefAccess().getValIdCrossReference_0());
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleIdRef"
+
+
+ // $ANTLR start "entryRuleId"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3824:1: entryRuleId returns [EObject current=null] : iv_ruleId= ruleId EOF ;
+ public final EObject entryRuleId() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleId = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3825:2: (iv_ruleId= ruleId EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3826:2: iv_ruleId= ruleId EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getIdRule());
+ }
+ pushFollow(FOLLOW_ruleId_in_entryRuleId8081);
+ iv_ruleId=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleId;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleId8091); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleId"
+
+
+ // $ANTLR start "ruleId"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3833:1: ruleId returns [EObject current=null] : ( (lv_name_0_0= RULE_IDENTIFIER ) ) ;
+ public final EObject ruleId() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_name_0_0=null;
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3836:28: ( ( (lv_name_0_0= RULE_IDENTIFIER ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3837:1: ( (lv_name_0_0= RULE_IDENTIFIER ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3837:1: ( (lv_name_0_0= RULE_IDENTIFIER ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3838:1: (lv_name_0_0= RULE_IDENTIFIER )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3838:1: (lv_name_0_0= RULE_IDENTIFIER )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3839:3: lv_name_0_0= RULE_IDENTIFIER
+ {
+ lv_name_0_0=(Token)match(input,RULE_IDENTIFIER,FOLLOW_RULE_IDENTIFIER_in_ruleId8132); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_name_0_0, grammarAccess.getIdAccess().getNameIDENTIFIERTerminalRuleCall_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getIdRule());
+ }
+ setWithLastConsumed(
+ current,
+ "name",
+ lv_name_0_0,
+ "IDENTIFIER");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleId"
+
+
+ // $ANTLR start "entryRuleProperty"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3863:1: entryRuleProperty returns [EObject current=null] : iv_ruleProperty= ruleProperty EOF ;
+ public final EObject entryRuleProperty() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleProperty = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3864:2: (iv_ruleProperty= ruleProperty EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3865:2: iv_ruleProperty= ruleProperty EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getPropertyRule());
+ }
+ pushFollow(FOLLOW_ruleProperty_in_entryRuleProperty8172);
+ iv_ruleProperty=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleProperty;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleProperty8182); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleProperty"
+
+
+ // $ANTLR start "ruleProperty"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3872:1: ruleProperty returns [EObject current=null] : ( ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) ) | ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END ) ) ;
+ public final EObject ruleProperty() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_accessor_1_1=null;
+ Token lv_accessor_1_2=null;
+ Token lv_accessor_1_3=null;
+ Token this_INDEX_START_4=null;
+ Token this_INDEX_END_6=null;
+ EObject this_IdRef_0 = null;
+
+ EObject lv_prop_2_0 = null;
+
+ EObject this_IdRef_3 = null;
+
+ EObject lv_index_5_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3875:28: ( ( ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) ) | ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:1: ( ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) ) | ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:1: ( ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) ) | ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END ) )
+ int alt69=2;
+ int LA69_0 = input.LA(1);
+
+ if ( (LA69_0==RULE_IDENTIFIER) ) {
+ int LA69_1 = input.LA(2);
+
+ if ( (LA69_1==RULE_INDEX_START) && (synpred30_InternalCakefile())) {
+ alt69=2;
+ }
+ else if ( (LA69_1==RULE_DOT) && (synpred29_InternalCakefile())) {
+ alt69=1;
+ }
+ else if ( (LA69_1==RULE_DOUBLE_COLON) && (synpred29_InternalCakefile())) {
+ alt69=1;
+ }
+ else if ( (LA69_1==RULE_QUESTION_DOT) && (synpred29_InternalCakefile())) {
+ alt69=1;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 69, 1, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 69, 0, input);
+
+ throw nvae;
+ }
+ switch (alt69) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:2: ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:2: ( ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:3: ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) ) ( (lv_prop_2_0= ruleId ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:3: ( ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:4: ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )=> (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3888:6: (this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3889:5: this_IdRef_0= ruleIdRef ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) )
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_0_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_ruleProperty8274);
+ this_IdRef_0=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IdRef_0;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3897:1: ( ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3898:1: ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3898:1: ( (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3899:1: (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3899:1: (lv_accessor_1_1= RULE_DOT | lv_accessor_1_2= RULE_DOUBLE_COLON | lv_accessor_1_3= RULE_QUESTION_DOT )
+ int alt68=3;
+ switch ( input.LA(1) ) {
+ case RULE_DOT:
+ {
+ alt68=1;
+ }
+ break;
+ case RULE_DOUBLE_COLON:
+ {
+ alt68=2;
+ }
+ break;
+ case RULE_QUESTION_DOT:
+ {
+ alt68=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 68, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt68) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3900:3: lv_accessor_1_1= RULE_DOT
+ {
+ lv_accessor_1_1=(Token)match(input,RULE_DOT,FOLLOW_RULE_DOT_in_ruleProperty8292); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_1_1, grammarAccess.getPropertyAccess().getAccessorDOTTerminalRuleCall_0_0_0_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_1_1,
+ "DOT");
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3915:8: lv_accessor_1_2= RULE_DOUBLE_COLON
+ {
+ lv_accessor_1_2=(Token)match(input,RULE_DOUBLE_COLON,FOLLOW_RULE_DOUBLE_COLON_in_ruleProperty8312); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_1_2, grammarAccess.getPropertyAccess().getAccessorDOUBLE_COLONTerminalRuleCall_0_0_0_1_0_1());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_1_2,
+ "DOUBLE_COLON");
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3930:8: lv_accessor_1_3= RULE_QUESTION_DOT
+ {
+ lv_accessor_1_3=(Token)match(input,RULE_QUESTION_DOT,FOLLOW_RULE_QUESTION_DOT_in_ruleProperty8332); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_accessor_1_3, grammarAccess.getPropertyAccess().getAccessorQUESTION_DOTTerminalRuleCall_0_0_0_1_0_2());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getPropertyRule());
+ }
+ setWithLastConsumed(
+ current,
+ "accessor",
+ lv_accessor_1_3,
+ "QUESTION_DOT");
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3948:4: ( (lv_prop_2_0= ruleId ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3949:1: (lv_prop_2_0= ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3949:1: (lv_prop_2_0= ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3950:3: lv_prop_2_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccess().getPropIdParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleProperty8363);
+ lv_prop_2_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ current,
+ "prop",
+ lv_prop_2_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:6: ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:6: ( ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:7: ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) ) ( (lv_index_5_0= ruleIndex ) ) this_INDEX_END_6= RULE_INDEX_END
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:7: ( ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:8: ( ( ruleIdRef RULE_INDEX_START ) )=> (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:41: (this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3968:5: this_IdRef_3= ruleIdRef this_INDEX_START_4= RULE_INDEX_START
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccess().getIdRefParserRuleCall_1_0_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleIdRef_in_ruleProperty8404);
+ this_IdRef_3=ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_IdRef_3;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_INDEX_START_4=(Token)match(input,RULE_INDEX_START,FOLLOW_RULE_INDEX_START_in_ruleProperty8414); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDEX_START_4, grammarAccess.getPropertyAccess().getINDEX_STARTTerminalRuleCall_1_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3980:3: ( (lv_index_5_0= ruleIndex ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3981:1: (lv_index_5_0= ruleIndex )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3981:1: (lv_index_5_0= ruleIndex )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3982:3: lv_index_5_0= ruleIndex
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getPropertyAccess().getIndexIndexParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleIndex_in_ruleProperty8436);
+ lv_index_5_0=ruleIndex();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getPropertyRule());
+ }
+ set(
+ current,
+ "index",
+ lv_index_5_0,
+ "Index");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_INDEX_END_6=(Token)match(input,RULE_INDEX_END,FOLLOW_RULE_INDEX_END_in_ruleProperty8447); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDEX_END_6, grammarAccess.getPropertyAccess().getINDEX_ENDTerminalRuleCall_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleProperty"
+
+
+ // $ANTLR start "entryRuleVariable"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4010:1: entryRuleVariable returns [EObject current=null] : iv_ruleVariable= ruleVariable EOF ;
+ public final EObject entryRuleVariable() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleVariable = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4011:2: (iv_ruleVariable= ruleVariable EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4012:2: iv_ruleVariable= ruleVariable EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getVariableRule());
+ }
+ pushFollow(FOLLOW_ruleVariable_in_entryRuleVariable8483);
+ iv_ruleVariable=ruleVariable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleVariable;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleVariable8493); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleVariable"
+
+
+ // $ANTLR start "ruleVariable"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4019:1: ruleVariable returns [EObject current=null] : (this_Id_0= ruleId | ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* ) | this_Property_7= ruleProperty ) ;
+ public final EObject ruleVariable() throws RecognitionException {
+ EObject current = null;
+
+ Token this_AT_SIGIL_1=null;
+ Token this_THIS_2=null;
+ Token this_DOT_3=null;
+ Token this_DOT_5=null;
+ EObject this_Id_0 = null;
+
+ EObject this_Id_4 = null;
+
+ EObject lv_props_6_0 = null;
+
+ EObject this_Property_7 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4022:28: ( (this_Id_0= ruleId | ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* ) | this_Property_7= ruleProperty ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4023:1: (this_Id_0= ruleId | ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* ) | this_Property_7= ruleProperty )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4023:1: (this_Id_0= ruleId | ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* ) | this_Property_7= ruleProperty )
+ int alt72=3;
+ int LA72_0 = input.LA(1);
+
+ if ( (LA72_0==RULE_IDENTIFIER) ) {
+ int LA72_1 = input.LA(2);
+
+ if ( (LA72_1==EOF||LA72_1==RULE_COMMA||LA72_1==RULE_PARAM_END||(LA72_1>=RULE_CALL_END && LA72_1<=RULE_TERMINATOR)||LA72_1==RULE_EQUAL||LA72_1==RULE_POST_IF||(LA72_1>=RULE_FOR && LA72_1<=RULE_UNTIL)||LA72_1==RULE_BY||(LA72_1>=RULE_DOT_DOT && LA72_1<=RULE_MATH)||LA72_1==RULE_INDEX_END||LA72_1==RULE_RCURLY||LA72_1==RULE_RPAREN) ) {
+ alt72=1;
+ }
+ else if ( ((LA72_1>=RULE_DOT && LA72_1<=RULE_INDEX_START)) ) {
+ alt72=3;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 72, 1, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA72_0==RULE_AT_SIGIL||LA72_0==RULE_THIS) ) {
+ alt72=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 72, 0, input);
+
+ throw nvae;
+ }
+ switch (alt72) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4024:5: this_Id_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getVariableAccess().getIdParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleVariable8540);
+ this_Id_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4033:6: ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4033:6: ( (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4033:7: (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) ) this_Id_4= ruleId (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )*
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4033:7: (this_AT_SIGIL_1= RULE_AT_SIGIL | (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT ) )
+ int alt70=2;
+ int LA70_0 = input.LA(1);
+
+ if ( (LA70_0==RULE_AT_SIGIL) ) {
+ alt70=1;
+ }
+ else if ( (LA70_0==RULE_THIS) ) {
+ alt70=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 70, 0, input);
+
+ throw nvae;
+ }
+ switch (alt70) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4033:8: this_AT_SIGIL_1= RULE_AT_SIGIL
+ {
+ this_AT_SIGIL_1=(Token)match(input,RULE_AT_SIGIL,FOLLOW_RULE_AT_SIGIL_in_ruleVariable8558); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_AT_SIGIL_1, grammarAccess.getVariableAccess().getAT_SIGILTerminalRuleCall_1_0_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4038:6: (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4038:6: (this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4038:7: this_THIS_2= RULE_THIS this_DOT_3= RULE_DOT
+ {
+ this_THIS_2=(Token)match(input,RULE_THIS,FOLLOW_RULE_THIS_in_ruleVariable8575); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_THIS_2, grammarAccess.getVariableAccess().getTHISTerminalRuleCall_1_0_1_0());
+
+ }
+ this_DOT_3=(Token)match(input,RULE_DOT,FOLLOW_RULE_DOT_in_ruleVariable8585); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_DOT_3, grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_0_1_1());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getVariableAccess().getIdParserRuleCall_1_1());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleVariable8608);
+ this_Id_4=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_4;
+ afterParserOrEnumRuleCall();
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4055:1: (this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) ) )*
+ loop71:
+ do {
+ int alt71=2;
+ int LA71_0 = input.LA(1);
+
+ if ( (LA71_0==RULE_DOT) ) {
+ alt71=1;
+ }
+
+
+ switch (alt71) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4055:2: this_DOT_5= RULE_DOT ( (lv_props_6_0= ruleId ) )
+ {
+ this_DOT_5=(Token)match(input,RULE_DOT,FOLLOW_RULE_DOT_in_ruleVariable8619); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_DOT_5, grammarAccess.getVariableAccess().getDOTTerminalRuleCall_1_2_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4059:1: ( (lv_props_6_0= ruleId ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4060:1: (lv_props_6_0= ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4060:1: (lv_props_6_0= ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4061:3: lv_props_6_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getVariableAccess().getPropsIdParserRuleCall_1_2_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleVariable8639);
+ lv_props_6_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getVariableRule());
+ }
+ add(
+ current,
+ "props",
+ lv_props_6_0,
+ "Id");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop71;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4079:5: this_Property_7= ruleProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getVariableAccess().getPropertyParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleProperty_in_ruleVariable8670);
+ this_Property_7=ruleProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Property_7;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleVariable"
+
+
+ // $ANTLR start "entryRuleAssignableArray"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4095:1: entryRuleAssignableArray returns [EObject current=null] : iv_ruleAssignableArray= ruleAssignableArray EOF ;
+ public final EObject entryRuleAssignableArray() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignableArray = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4096:2: (iv_ruleAssignableArray= ruleAssignableArray EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4097:2: iv_ruleAssignableArray= ruleAssignableArray EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignableArrayRule());
+ }
+ pushFollow(FOLLOW_ruleAssignableArray_in_entryRuleAssignableArray8705);
+ iv_ruleAssignableArray=ruleAssignableArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignableArray;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignableArray8715); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignableArray"
+
+
+ // $ANTLR start "ruleAssignableArray"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4104:1: ruleAssignableArray returns [EObject current=null] : ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET ) ;
+ public final EObject ruleAssignableArray() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LBRACKET_0=null;
+ Token this_RBRACKET_2=null;
+ EObject this_AssignableArgList_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4107:28: ( ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4108:1: ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4108:1: ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4108:2: ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_AssignableArgList_1= ruleAssignableArgList this_RBRACKET_2= RULE_RBRACKET
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4108:2: ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4108:3: ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET
+ {
+ this_LBRACKET_0=(Token)match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_ruleAssignableArray8757); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LBRACKET_0, grammarAccess.getAssignableArrayAccess().getLBRACKETTerminalRuleCall_0());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableArrayAccess().getAssignableArgListParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleAssignableArgList_in_ruleAssignableArray8779);
+ this_AssignableArgList_1=ruleAssignableArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_AssignableArgList_1;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_RBRACKET_2=(Token)match(input,RULE_RBRACKET,FOLLOW_RULE_RBRACKET_in_ruleAssignableArray8789); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RBRACKET_2, grammarAccess.getAssignableArrayAccess().getRBRACKETTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignableArray"
+
+
+ // $ANTLR start "entryRuleAssignableArgList"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4133:1: entryRuleAssignableArgList returns [EObject current=null] : iv_ruleAssignableArgList= ruleAssignableArgList EOF ;
+ public final EObject entryRuleAssignableArgList() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignableArgList = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4134:2: (iv_ruleAssignableArgList= ruleAssignableArgList EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4135:2: iv_ruleAssignableArgList= ruleAssignableArgList EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignableArgListRule());
+ }
+ pushFollow(FOLLOW_ruleAssignableArgList_in_entryRuleAssignableArgList8824);
+ iv_ruleAssignableArgList=ruleAssignableArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignableArgList;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignableArgList8834); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignableArgList"
+
+
+ // $ANTLR start "ruleAssignableArgList"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4142:1: ruleAssignableArgList returns [EObject current=null] : ( ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )* ) ;
+ public final EObject ruleAssignableArgList() throws RecognitionException {
+ EObject current = null;
+
+ Token this_COMMA_1=null;
+ EObject lv_args_0_0 = null;
+
+ EObject lv_args_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4145:28: ( ( ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4146:1: ( ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4146:1: ( ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4146:2: ( (lv_args_0_0= ruleAssignableArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )*
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4146:2: ( (lv_args_0_0= ruleAssignableArg ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4147:1: (lv_args_0_0= ruleAssignableArg )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4147:1: (lv_args_0_0= ruleAssignableArg )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4148:3: lv_args_0_0= ruleAssignableArg
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignableArg_in_ruleAssignableArgList8880);
+ lv_args_0_0=ruleAssignableArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignableArgListRule());
+ }
+ add(
+ current,
+ "args",
+ lv_args_0_0,
+ "AssignableArg");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4164:2: (this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) ) )*
+ loop73:
+ do {
+ int alt73=2;
+ int LA73_0 = input.LA(1);
+
+ if ( (LA73_0==RULE_COMMA) ) {
+ alt73=1;
+ }
+
+
+ switch (alt73) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4164:3: this_COMMA_1= RULE_COMMA ( (lv_args_2_0= ruleAssignableArg ) )
+ {
+ this_COMMA_1=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleAssignableArgList8892); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_1, grammarAccess.getAssignableArgListAccess().getCOMMATerminalRuleCall_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4168:1: ( (lv_args_2_0= ruleAssignableArg ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4169:1: (lv_args_2_0= ruleAssignableArg )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4169:1: (lv_args_2_0= ruleAssignableArg )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4170:3: lv_args_2_0= ruleAssignableArg
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableArgListAccess().getArgsAssignableArgParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignableArg_in_ruleAssignableArgList8912);
+ lv_args_2_0=ruleAssignableArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignableArgListRule());
+ }
+ add(
+ current,
+ "args",
+ lv_args_2_0,
+ "AssignableArg");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop73;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignableArgList"
+
+
+ // $ANTLR start "entryRuleAssignableArg"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4194:1: entryRuleAssignableArg returns [EObject current=null] : iv_ruleAssignableArg= ruleAssignableArg EOF ;
+ public final EObject entryRuleAssignableArg() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignableArg = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4195:2: (iv_ruleAssignableArg= ruleAssignableArg EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4196:2: iv_ruleAssignableArg= ruleAssignableArg EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignableArgRule());
+ }
+ pushFollow(FOLLOW_ruleAssignableArg_in_entryRuleAssignableArg8950);
+ iv_ruleAssignableArg=ruleAssignableArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignableArg;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignableArg8960); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignableArg"
+
+
+ // $ANTLR start "ruleAssignableArg"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4203:1: ruleAssignableArg returns [EObject current=null] : ( ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? ) ;
+ public final EObject ruleAssignableArg() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_splat_1_0=null;
+ EObject lv_arg_0_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4206:28: ( ( ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4207:1: ( ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4207:1: ( ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4207:2: ( (lv_arg_0_0= ruleAssignable ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4207:2: ( (lv_arg_0_0= ruleAssignable ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4208:1: (lv_arg_0_0= ruleAssignable )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4208:1: (lv_arg_0_0= ruleAssignable )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4209:3: lv_arg_0_0= ruleAssignable
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableArgAccess().getArgAssignableParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleAssignable_in_ruleAssignableArg9006);
+ lv_arg_0_0=ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAssignableArgRule());
+ }
+ set(
+ current,
+ "arg",
+ lv_arg_0_0,
+ "Assignable");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4225:2: ( (lv_splat_1_0= RULE_ELLIPSIS ) )?
+ int alt74=2;
+ int LA74_0 = input.LA(1);
+
+ if ( (LA74_0==RULE_ELLIPSIS) ) {
+ alt74=1;
+ }
+ switch (alt74) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4226:1: (lv_splat_1_0= RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4226:1: (lv_splat_1_0= RULE_ELLIPSIS )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4227:3: lv_splat_1_0= RULE_ELLIPSIS
+ {
+ lv_splat_1_0=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleAssignableArg9023); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_splat_1_0, grammarAccess.getAssignableArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAssignableArgRule());
+ }
+ setWithLastConsumed(
+ current,
+ "splat",
+ true,
+ "ELLIPSIS");
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignableArg"
+
+
+ // $ANTLR start "entryRuleAssignable"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4251:1: entryRuleAssignable returns [EObject current=null] : iv_ruleAssignable= ruleAssignable EOF ;
+ public final EObject entryRuleAssignable() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAssignable = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4252:2: (iv_ruleAssignable= ruleAssignable EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4253:2: iv_ruleAssignable= ruleAssignable EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAssignableRule());
+ }
+ pushFollow(FOLLOW_ruleAssignable_in_entryRuleAssignable9065);
+ iv_ruleAssignable=ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAssignable;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAssignable9075); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAssignable"
+
+
+ // $ANTLR start "ruleAssignable"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4260:1: ruleAssignable returns [EObject current=null] : (this_Variable_0= ruleVariable | ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary ) | ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray ) ) ;
+ public final EObject ruleAssignable() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Variable_0 = null;
+
+ EObject this_Dictionary_1 = null;
+
+ EObject this_AssignableArray_2 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4263:28: ( (this_Variable_0= ruleVariable | ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary ) | ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4264:1: (this_Variable_0= ruleVariable | ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary ) | ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4264:1: (this_Variable_0= ruleVariable | ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary ) | ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray ) )
+ int alt75=3;
+ int LA75_0 = input.LA(1);
+
+ if ( (LA75_0==RULE_AT_SIGIL||LA75_0==RULE_THIS||LA75_0==RULE_IDENTIFIER) ) {
+ alt75=1;
+ }
+ else if ( (LA75_0==RULE_LCURLY) && (synpred32_InternalCakefile())) {
+ alt75=2;
+ }
+ else if ( (LA75_0==RULE_LBRACKET) && (synpred33_InternalCakefile())) {
+ alt75=3;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 75, 0, input);
+
+ throw nvae;
+ }
+ switch (alt75) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4265:5: this_Variable_0= ruleVariable
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableAccess().getVariableParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleVariable_in_ruleAssignable9122);
+ this_Variable_0=ruleVariable();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Variable_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4274:6: ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4274:6: ( ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4274:7: ( RULE_LCURLY )=>this_Dictionary_1= ruleDictionary
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableAccess().getDictionaryParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleDictionary_in_ruleAssignable9155);
+ this_Dictionary_1=ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Dictionary_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4284:6: ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4284:6: ( ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4284:7: ( RULE_LBRACKET )=>this_AssignableArray_2= ruleAssignableArray
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getAssignableAccess().getAssignableArrayParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleAssignableArray_in_ruleAssignable9189);
+ this_AssignableArray_2=ruleAssignableArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_AssignableArray_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAssignable"
+
+
+ // $ANTLR start "entryRuleArg"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4301:1: entryRuleArg returns [EObject current=null] : iv_ruleArg= ruleArg EOF ;
+ public final EObject entryRuleArg() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleArg = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4302:2: (iv_ruleArg= ruleArg EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4303:2: iv_ruleArg= ruleArg EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getArgRule());
+ }
+ pushFollow(FOLLOW_ruleArg_in_entryRuleArg9225);
+ iv_ruleArg=ruleArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleArg;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArg9235); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleArg"
+
+
+ // $ANTLR start "ruleArg"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4310:1: ruleArg returns [EObject current=null] : ( ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? ) ;
+ public final EObject ruleArg() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_splat_1_0=null;
+ EObject lv_exp_0_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4313:28: ( ( ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4314:1: ( ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4314:1: ( ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4314:2: ( (lv_exp_0_0= ruleExpression ) ) ( (lv_splat_1_0= RULE_ELLIPSIS ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4314:2: ( (lv_exp_0_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4315:1: (lv_exp_0_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4315:1: (lv_exp_0_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4316:3: lv_exp_0_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgAccess().getExpExpressionParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleArg9281);
+ lv_exp_0_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgRule());
+ }
+ set(
+ current,
+ "exp",
+ lv_exp_0_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4332:2: ( (lv_splat_1_0= RULE_ELLIPSIS ) )?
+ int alt76=2;
+ int LA76_0 = input.LA(1);
+
+ if ( (LA76_0==RULE_ELLIPSIS) ) {
+ alt76=1;
+ }
+ switch (alt76) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4333:1: (lv_splat_1_0= RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4333:1: (lv_splat_1_0= RULE_ELLIPSIS )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4334:3: lv_splat_1_0= RULE_ELLIPSIS
+ {
+ lv_splat_1_0=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleArg9298); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_splat_1_0, grammarAccess.getArgAccess().getSplatELLIPSISTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getArgRule());
+ }
+ setWithLastConsumed(
+ current,
+ "splat",
+ true,
+ "ELLIPSIS");
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleArg"
+
+
+ // $ANTLR start "entryRuleArgLine"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4358:1: entryRuleArgLine returns [EObject current=null] : iv_ruleArgLine= ruleArgLine EOF ;
+ public final EObject entryRuleArgLine() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleArgLine = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4359:2: (iv_ruleArgLine= ruleArgLine EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4360:2: iv_ruleArgLine= ruleArgLine EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getArgLineRule());
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_entryRuleArgLine9340);
+ iv_ruleArgLine=ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleArgLine;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArgLine9350); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleArgLine"
+
+
+ // $ANTLR start "ruleArgLine"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4367:1: ruleArgLine returns [EObject current=null] : ( ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )? ) ;
+ public final EObject ruleArgLine() throws RecognitionException {
+ EObject current = null;
+
+ Token this_COMMA_1=null;
+ Token this_COMMA_3=null;
+ EObject lv_head_0_0 = null;
+
+ EObject lv_tail_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4370:28: ( ( ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4371:1: ( ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4371:1: ( ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4371:2: ( (lv_head_0_0= ruleArg ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )* (this_COMMA_3= RULE_COMMA )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4371:2: ( (lv_head_0_0= ruleArg ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4372:1: (lv_head_0_0= ruleArg )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4372:1: (lv_head_0_0= ruleArg )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4373:3: lv_head_0_0= ruleArg
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgLineAccess().getHeadArgParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleArg_in_ruleArgLine9396);
+ lv_head_0_0=ruleArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgLineRule());
+ }
+ set(
+ current,
+ "head",
+ lv_head_0_0,
+ "Arg");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4389:2: (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) ) )*
+ loop77:
+ do {
+ int alt77=2;
+ int LA77_0 = input.LA(1);
+
+ if ( (LA77_0==RULE_COMMA) ) {
+ int LA77_1 = input.LA(2);
+
+ if ( (LA77_1==RULE_PARAM_START||LA77_1==RULE_FUNC_ARROW||LA77_1==RULE_STRING||(LA77_1>=RULE_FOR && LA77_1<=RULE_WHILE)||LA77_1==RULE_UNTIL||LA77_1==RULE_LBRACKET||(LA77_1>=RULE_PLUS && LA77_1<=RULE_MINUS)||(LA77_1>=RULE_UNARY && LA77_1<=RULE_MINUS_MINUS)||LA77_1==RULE_SUPER||LA77_1==RULE_AT_SIGIL||(LA77_1>=RULE_THIS && LA77_1<=RULE_TRY)||LA77_1==RULE_SWITCH||(LA77_1>=RULE_IF && LA77_1<=RULE_LCURLY)||(LA77_1>=RULE_BOUND_FUNC_ARROW && LA77_1<=RULE_LPAREN)) ) {
+ alt77=1;
+ }
+
+
+ }
+
+
+ switch (alt77) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4389:3: this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleArg ) )
+ {
+ this_COMMA_1=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleArgLine9408); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_1, grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4393:1: ( (lv_tail_2_0= ruleArg ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4394:1: (lv_tail_2_0= ruleArg )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4394:1: (lv_tail_2_0= ruleArg )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4395:3: lv_tail_2_0= ruleArg
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgLineAccess().getTailArgParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleArg_in_ruleArgLine9428);
+ lv_tail_2_0=ruleArg();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgLineRule());
+ }
+ add(
+ current,
+ "tail",
+ lv_tail_2_0,
+ "Arg");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop77;
+ }
+ } while (true);
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4411:4: (this_COMMA_3= RULE_COMMA )?
+ int alt78=2;
+ int LA78_0 = input.LA(1);
+
+ if ( (LA78_0==RULE_COMMA) ) {
+ alt78=1;
+ }
+ switch (alt78) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4411:5: this_COMMA_3= RULE_COMMA
+ {
+ this_COMMA_3=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleArgLine9442); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_3, grammarAccess.getArgLineAccess().getCOMMATerminalRuleCall_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleArgLine"
+
+
+ // $ANTLR start "entryRuleExplicitArgList"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4423:1: entryRuleExplicitArgList returns [EObject current=null] : iv_ruleExplicitArgList= ruleExplicitArgList EOF ;
+ public final EObject entryRuleExplicitArgList() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleExplicitArgList = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4424:2: (iv_ruleExplicitArgList= ruleExplicitArgList EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4425:2: iv_ruleExplicitArgList= ruleExplicitArgList EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getExplicitArgListRule());
+ }
+ pushFollow(FOLLOW_ruleExplicitArgList_in_entryRuleExplicitArgList9479);
+ iv_ruleExplicitArgList=ruleExplicitArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleExplicitArgList;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExplicitArgList9489); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleExplicitArgList"
+
+
+ // $ANTLR start "ruleExplicitArgList"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4432:1: ruleExplicitArgList returns [EObject current=null] : ( ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* ) ;
+ public final EObject ruleExplicitArgList() throws RecognitionException {
+ EObject current = null;
+
+ Token this_TERMINATOR_1=null;
+ Token this_INDENT_3=null;
+ Token this_OUTDENT_5=null;
+ EObject lv_lines_0_0 = null;
+
+ EObject lv_lines_2_0 = null;
+
+ EObject lv_lines_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4435:28: ( ( ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4436:1: ( ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4436:1: ( ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4436:2: ( (lv_lines_0_0= ruleArgLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )*
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4436:2: ( (lv_lines_0_0= ruleArgLine ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4437:1: (lv_lines_0_0= ruleArgLine )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4437:1: (lv_lines_0_0= ruleArgLine )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4438:3: lv_lines_0_0= ruleArgLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_ruleExplicitArgList9535);
+ lv_lines_0_0=ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_0_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4454:2: ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )*
+ loop79:
+ do {
+ int alt79=3;
+ int LA79_0 = input.LA(1);
+
+ if ( (LA79_0==RULE_TERMINATOR) ) {
+ alt79=1;
+ }
+ else if ( (LA79_0==RULE_INDENT) ) {
+ alt79=2;
+ }
+
+
+ switch (alt79) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4454:3: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4454:3: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4454:4: this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleArgLine ) )
+ {
+ this_TERMINATOR_1=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleExplicitArgList9548); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getExplicitArgListAccess().getTERMINATORTerminalRuleCall_1_0_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4458:1: ( (lv_lines_2_0= ruleArgLine ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4459:1: (lv_lines_2_0= ruleArgLine )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4459:1: (lv_lines_2_0= ruleArgLine )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4460:3: lv_lines_2_0= ruleArgLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_ruleExplicitArgList9568);
+ lv_lines_2_0=ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_2_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4477:6: (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4477:6: (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4477:7: this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleArgLine ) ) this_OUTDENT_5= RULE_OUTDENT
+ {
+ this_INDENT_3=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleExplicitArgList9587); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_3, grammarAccess.getExplicitArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4481:1: ( (lv_lines_4_0= ruleArgLine ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4482:1: (lv_lines_4_0= ruleArgLine )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4482:1: (lv_lines_4_0= ruleArgLine )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4483:3: lv_lines_4_0= ruleArgLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitArgListAccess().getLinesArgLineParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleArgLine_in_ruleExplicitArgList9607);
+ lv_lines_4_0=ruleArgLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitArgListRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_4_0,
+ "ArgLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_5=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleExplicitArgList9618); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_5, grammarAccess.getExplicitArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop79;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleExplicitArgList"
+
+
+ // $ANTLR start "entryRuleArgList"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4511:1: entryRuleArgList returns [EObject current=null] : iv_ruleArgList= ruleArgList EOF ;
+ public final EObject entryRuleArgList() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleArgList = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4512:2: (iv_ruleArgList= ruleArgList EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4513:2: iv_ruleArgList= ruleArgList EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getArgListRule());
+ }
+ pushFollow(FOLLOW_ruleArgList_in_entryRuleArgList9656);
+ iv_ruleArgList=ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleArgList;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArgList9666); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleArgList"
+
+
+ // $ANTLR start "ruleArgList"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4520:1: ruleArgList returns [EObject current=null] : ( () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )? ) ;
+ public final EObject ruleArgList() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDENT_2=null;
+ Token this_OUTDENT_4=null;
+ EObject lv_dummy_1_0 = null;
+
+ EObject lv_dummy_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4523:28: ( ( () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4524:1: ( () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4524:1: ( () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4524:2: () ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4524:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4525:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getArgListAccess().getArgListAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4530:2: ( ( (lv_dummy_1_0= ruleExplicitArgList ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT ) )?
+ int alt80=3;
+ int LA80_0 = input.LA(1);
+
+ if ( (LA80_0==RULE_PARAM_START||LA80_0==RULE_FUNC_ARROW||LA80_0==RULE_STRING||(LA80_0>=RULE_FOR && LA80_0<=RULE_WHILE)||LA80_0==RULE_UNTIL||LA80_0==RULE_LBRACKET||(LA80_0>=RULE_PLUS && LA80_0<=RULE_MINUS)||(LA80_0>=RULE_UNARY && LA80_0<=RULE_MINUS_MINUS)||LA80_0==RULE_SUPER||LA80_0==RULE_AT_SIGIL||(LA80_0>=RULE_THIS && LA80_0<=RULE_TRY)||LA80_0==RULE_SWITCH||(LA80_0>=RULE_IF && LA80_0<=RULE_LCURLY)||(LA80_0>=RULE_BOUND_FUNC_ARROW && LA80_0<=RULE_LPAREN)) ) {
+ alt80=1;
+ }
+ else if ( (LA80_0==RULE_INDENT) ) {
+ alt80=2;
+ }
+ switch (alt80) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4530:3: ( (lv_dummy_1_0= ruleExplicitArgList ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4530:3: ( (lv_dummy_1_0= ruleExplicitArgList ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4531:1: (lv_dummy_1_0= ruleExplicitArgList )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4531:1: (lv_dummy_1_0= ruleExplicitArgList )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4532:3: lv_dummy_1_0= ruleExplicitArgList
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExplicitArgList_in_ruleArgList9722);
+ lv_dummy_1_0=ruleExplicitArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgListRule());
+ }
+ set(
+ current,
+ "dummy",
+ lv_dummy_1_0,
+ "ExplicitArgList");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4549:6: (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4549:6: (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4549:7: this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitArgList ) ) this_OUTDENT_4= RULE_OUTDENT
+ {
+ this_INDENT_2=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleArgList9740); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_2, grammarAccess.getArgListAccess().getINDENTTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4553:1: ( (lv_dummy_3_0= ruleExplicitArgList ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4554:1: (lv_dummy_3_0= ruleExplicitArgList )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4554:1: (lv_dummy_3_0= ruleExplicitArgList )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4555:3: lv_dummy_3_0= ruleExplicitArgList
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArgListAccess().getDummyExplicitArgListParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExplicitArgList_in_ruleArgList9760);
+ lv_dummy_3_0=ruleExplicitArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getArgListRule());
+ }
+ set(
+ current,
+ "dummy",
+ lv_dummy_3_0,
+ "ExplicitArgList");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_4=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleArgList9771); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_4, grammarAccess.getArgListAccess().getOUTDENTTerminalRuleCall_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleArgList"
+
+
+ // $ANTLR start "entryRuleArray"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4583:1: entryRuleArray returns [EObject current=null] : iv_ruleArray= ruleArray EOF ;
+ public final EObject entryRuleArray() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleArray = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4584:2: (iv_ruleArray= ruleArray EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4585:2: iv_ruleArray= ruleArray EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getArrayRule());
+ }
+ pushFollow(FOLLOW_ruleArray_in_entryRuleArray9809);
+ iv_ruleArray=ruleArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleArray;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleArray9819); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleArray"
+
+
+ // $ANTLR start "ruleArray"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4592:1: ruleArray returns [EObject current=null] : ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET ) ;
+ public final EObject ruleArray() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LBRACKET_0=null;
+ Token this_RBRACKET_2=null;
+ EObject this_ArgList_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4595:28: ( ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4596:1: ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4596:1: ( ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4596:2: ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET ) this_ArgList_1= ruleArgList this_RBRACKET_2= RULE_RBRACKET
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4596:2: ( ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4596:3: ( RULE_LBRACKET )=>this_LBRACKET_0= RULE_LBRACKET
+ {
+ this_LBRACKET_0=(Token)match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_ruleArray9861); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LBRACKET_0, grammarAccess.getArrayAccess().getLBRACKETTerminalRuleCall_0());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getArrayAccess().getArgListParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleArgList_in_ruleArray9883);
+ this_ArgList_1=ruleArgList();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ArgList_1;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_RBRACKET_2=(Token)match(input,RULE_RBRACKET,FOLLOW_RULE_RBRACKET_in_ruleArray9893); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RBRACKET_2, grammarAccess.getArrayAccess().getRBRACKETTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleArray"
+
+
+ // $ANTLR start "entryRuleDictionary"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4621:1: entryRuleDictionary returns [EObject current=null] : iv_ruleDictionary= ruleDictionary EOF ;
+ public final EObject entryRuleDictionary() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictionary = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4622:2: (iv_ruleDictionary= ruleDictionary EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4623:2: iv_ruleDictionary= ruleDictionary EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictionaryRule());
+ }
+ pushFollow(FOLLOW_ruleDictionary_in_entryRuleDictionary9928);
+ iv_ruleDictionary=ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictionary;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictionary9938); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictionary"
+
+
+ // $ANTLR start "ruleDictionary"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4630:1: ruleDictionary returns [EObject current=null] : ( ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY ) ;
+ public final EObject ruleDictionary() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LCURLY_0=null;
+ Token this_RCURLY_2=null;
+ EObject this_DictItems_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4633:28: ( ( ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4634:1: ( ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4634:1: ( ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4634:2: ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY ) this_DictItems_1= ruleDictItems this_RCURLY_2= RULE_RCURLY
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4634:2: ( ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4634:3: ( RULE_LCURLY )=>this_LCURLY_0= RULE_LCURLY
+ {
+ this_LCURLY_0=(Token)match(input,RULE_LCURLY,FOLLOW_RULE_LCURLY_in_ruleDictionary9980); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LCURLY_0, grammarAccess.getDictionaryAccess().getLCURLYTerminalRuleCall_0());
+
+ }
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictionaryAccess().getDictItemsParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleDictItems_in_ruleDictionary10002);
+ this_DictItems_1=ruleDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_DictItems_1;
+ afterParserOrEnumRuleCall();
+
+ }
+ this_RCURLY_2=(Token)match(input,RULE_RCURLY,FOLLOW_RULE_RCURLY_in_ruleDictionary10012); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RCURLY_2, grammarAccess.getDictionaryAccess().getRCURLYTerminalRuleCall_2());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictionary"
+
+
+ // $ANTLR start "entryRuleDictItems"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4659:1: entryRuleDictItems returns [EObject current=null] : iv_ruleDictItems= ruleDictItems EOF ;
+ public final EObject entryRuleDictItems() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictItems = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4660:2: (iv_ruleDictItems= ruleDictItems EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4661:2: iv_ruleDictItems= ruleDictItems EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictItemsRule());
+ }
+ pushFollow(FOLLOW_ruleDictItems_in_entryRuleDictItems10047);
+ iv_ruleDictItems=ruleDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictItems;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictItems10057); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictItems"
+
+
+ // $ANTLR start "ruleDictItems"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4668:1: ruleDictItems returns [EObject current=null] : ( () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )? ) ;
+ public final EObject ruleDictItems() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDENT_2=null;
+ Token this_OUTDENT_4=null;
+ EObject lv_dummy_1_0 = null;
+
+ EObject lv_dummy_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4671:28: ( ( () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4672:1: ( () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4672:1: ( () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4672:2: () ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4672:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4673:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getDictItemsAccess().getDictItemsAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4678:2: ( ( (lv_dummy_1_0= ruleExplicitDictItems ) ) | (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT ) )?
+ int alt81=3;
+ int LA81_0 = input.LA(1);
+
+ if ( (LA81_0==RULE_STRING||LA81_0==RULE_IDENTIFIER||(LA81_0>=RULE_NUMBER && LA81_0<=RULE_REGEX)) ) {
+ alt81=1;
+ }
+ else if ( (LA81_0==RULE_INDENT) ) {
+ alt81=2;
+ }
+ switch (alt81) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4678:3: ( (lv_dummy_1_0= ruleExplicitDictItems ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4678:3: ( (lv_dummy_1_0= ruleExplicitDictItems ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4679:1: (lv_dummy_1_0= ruleExplicitDictItems )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4679:1: (lv_dummy_1_0= ruleExplicitDictItems )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4680:3: lv_dummy_1_0= ruleExplicitDictItems
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExplicitDictItems_in_ruleDictItems10113);
+ lv_dummy_1_0=ruleExplicitDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemsRule());
+ }
+ set(
+ current,
+ "dummy",
+ lv_dummy_1_0,
+ "ExplicitDictItems");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4697:6: (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4697:6: (this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4697:7: this_INDENT_2= RULE_INDENT ( (lv_dummy_3_0= ruleExplicitDictItems ) ) this_OUTDENT_4= RULE_OUTDENT
+ {
+ this_INDENT_2=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleDictItems10131); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_2, grammarAccess.getDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4701:1: ( (lv_dummy_3_0= ruleExplicitDictItems ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4702:1: (lv_dummy_3_0= ruleExplicitDictItems )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4702:1: (lv_dummy_3_0= ruleExplicitDictItems )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4703:3: lv_dummy_3_0= ruleExplicitDictItems
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemsAccess().getDummyExplicitDictItemsParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExplicitDictItems_in_ruleDictItems10151);
+ lv_dummy_3_0=ruleExplicitDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemsRule());
+ }
+ set(
+ current,
+ "dummy",
+ lv_dummy_3_0,
+ "ExplicitDictItems");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_4=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleDictItems10162); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_4, grammarAccess.getDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictItems"
+
+
+ // $ANTLR start "entryRuleExplicitDictItems"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4731:1: entryRuleExplicitDictItems returns [EObject current=null] : iv_ruleExplicitDictItems= ruleExplicitDictItems EOF ;
+ public final EObject entryRuleExplicitDictItems() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleExplicitDictItems = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4732:2: (iv_ruleExplicitDictItems= ruleExplicitDictItems EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4733:2: iv_ruleExplicitDictItems= ruleExplicitDictItems EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getExplicitDictItemsRule());
+ }
+ pushFollow(FOLLOW_ruleExplicitDictItems_in_entryRuleExplicitDictItems10200);
+ iv_ruleExplicitDictItems=ruleExplicitDictItems();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleExplicitDictItems;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExplicitDictItems10210); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleExplicitDictItems"
+
+
+ // $ANTLR start "ruleExplicitDictItems"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4740:1: ruleExplicitDictItems returns [EObject current=null] : ( ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* ) ;
+ public final EObject ruleExplicitDictItems() throws RecognitionException {
+ EObject current = null;
+
+ Token this_TERMINATOR_1=null;
+ Token this_INDENT_3=null;
+ Token this_OUTDENT_5=null;
+ EObject lv_lines_0_0 = null;
+
+ EObject lv_lines_2_0 = null;
+
+ EObject lv_lines_4_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4743:28: ( ( ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4744:1: ( ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4744:1: ( ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )* )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4744:2: ( (lv_lines_0_0= ruleDictLine ) ) ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )*
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4744:2: ( (lv_lines_0_0= ruleDictLine ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4745:1: (lv_lines_0_0= ruleDictLine )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4745:1: (lv_lines_0_0= ruleDictLine )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4746:3: lv_lines_0_0= ruleDictLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_ruleExplicitDictItems10256);
+ lv_lines_0_0=ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_0_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4762:2: ( (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) ) | (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT ) )*
+ loop82:
+ do {
+ int alt82=3;
+ int LA82_0 = input.LA(1);
+
+ if ( (LA82_0==RULE_TERMINATOR) ) {
+ alt82=1;
+ }
+ else if ( (LA82_0==RULE_INDENT) ) {
+ alt82=2;
+ }
+
+
+ switch (alt82) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4762:3: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4762:3: (this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4762:4: this_TERMINATOR_1= RULE_TERMINATOR ( (lv_lines_2_0= ruleDictLine ) )
+ {
+ this_TERMINATOR_1=(Token)match(input,RULE_TERMINATOR,FOLLOW_RULE_TERMINATOR_in_ruleExplicitDictItems10269); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_TERMINATOR_1, grammarAccess.getExplicitDictItemsAccess().getTERMINATORTerminalRuleCall_1_0_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4766:1: ( (lv_lines_2_0= ruleDictLine ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4767:1: (lv_lines_2_0= ruleDictLine )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4767:1: (lv_lines_2_0= ruleDictLine )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4768:3: lv_lines_2_0= ruleDictLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_ruleExplicitDictItems10289);
+ lv_lines_2_0=ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_2_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4785:6: (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4785:6: (this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4785:7: this_INDENT_3= RULE_INDENT ( (lv_lines_4_0= ruleDictLine ) ) this_OUTDENT_5= RULE_OUTDENT
+ {
+ this_INDENT_3=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleExplicitDictItems10308); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_3, grammarAccess.getExplicitDictItemsAccess().getINDENTTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4789:1: ( (lv_lines_4_0= ruleDictLine ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4790:1: (lv_lines_4_0= ruleDictLine )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4790:1: (lv_lines_4_0= ruleDictLine )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4791:3: lv_lines_4_0= ruleDictLine
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getExplicitDictItemsAccess().getLinesDictLineParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_ruleExplicitDictItems10328);
+ lv_lines_4_0=ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExplicitDictItemsRule());
+ }
+ add(
+ current,
+ "lines",
+ lv_lines_4_0,
+ "DictLine");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_5=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleExplicitDictItems10339); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_5, grammarAccess.getExplicitDictItemsAccess().getOUTDENTTerminalRuleCall_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop82;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleExplicitDictItems"
+
+
+ // $ANTLR start "entryRuleDictLine"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4819:1: entryRuleDictLine returns [EObject current=null] : iv_ruleDictLine= ruleDictLine EOF ;
+ public final EObject entryRuleDictLine() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictLine = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4820:2: (iv_ruleDictLine= ruleDictLine EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4821:2: iv_ruleDictLine= ruleDictLine EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictLineRule());
+ }
+ pushFollow(FOLLOW_ruleDictLine_in_entryRuleDictLine10377);
+ iv_ruleDictLine=ruleDictLine();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictLine;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictLine10387); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictLine"
+
+
+ // $ANTLR start "ruleDictLine"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4828:1: ruleDictLine returns [EObject current=null] : ( ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )? ) ;
+ public final EObject ruleDictLine() throws RecognitionException {
+ EObject current = null;
+
+ Token this_COMMA_1=null;
+ Token this_COMMA_3=null;
+ EObject lv_head_0_0 = null;
+
+ EObject lv_tail_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4831:28: ( ( ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4832:1: ( ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4832:1: ( ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4832:2: ( (lv_head_0_0= ruleDictItem ) ) (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )* (this_COMMA_3= RULE_COMMA )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4832:2: ( (lv_head_0_0= ruleDictItem ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4833:1: (lv_head_0_0= ruleDictItem )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4833:1: (lv_head_0_0= ruleDictItem )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4834:3: lv_head_0_0= ruleDictItem
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictLineAccess().getHeadDictItemParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictItem_in_ruleDictLine10433);
+ lv_head_0_0=ruleDictItem();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictLineRule());
+ }
+ set(
+ current,
+ "head",
+ lv_head_0_0,
+ "DictItem");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4850:2: (this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) ) )*
+ loop83:
+ do {
+ int alt83=2;
+ int LA83_0 = input.LA(1);
+
+ if ( (LA83_0==RULE_COMMA) ) {
+ int LA83_1 = input.LA(2);
+
+ if ( (LA83_1==RULE_STRING||LA83_1==RULE_IDENTIFIER||(LA83_1>=RULE_NUMBER && LA83_1<=RULE_REGEX)) ) {
+ alt83=1;
+ }
+
+
+ }
+
+
+ switch (alt83) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4850:3: this_COMMA_1= RULE_COMMA ( (lv_tail_2_0= ruleDictItem ) )
+ {
+ this_COMMA_1=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleDictLine10445); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_1, grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4854:1: ( (lv_tail_2_0= ruleDictItem ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4855:1: (lv_tail_2_0= ruleDictItem )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4855:1: (lv_tail_2_0= ruleDictItem )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4856:3: lv_tail_2_0= ruleDictItem
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictLineAccess().getTailDictItemParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictItem_in_ruleDictLine10465);
+ lv_tail_2_0=ruleDictItem();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictLineRule());
+ }
+ add(
+ current,
+ "tail",
+ lv_tail_2_0,
+ "DictItem");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop83;
+ }
+ } while (true);
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4872:4: (this_COMMA_3= RULE_COMMA )?
+ int alt84=2;
+ int LA84_0 = input.LA(1);
+
+ if ( (LA84_0==RULE_COMMA) ) {
+ alt84=1;
+ }
+ switch (alt84) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4872:5: this_COMMA_3= RULE_COMMA
+ {
+ this_COMMA_3=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleDictLine10479); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_3, grammarAccess.getDictLineAccess().getCOMMATerminalRuleCall_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictLine"
+
+
+ // $ANTLR start "entryRuleDictItem"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4884:1: entryRuleDictItem returns [EObject current=null] : iv_ruleDictItem= ruleDictItem EOF ;
+ public final EObject entryRuleDictItem() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictItem = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4885:2: (iv_ruleDictItem= ruleDictItem EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4886:2: iv_ruleDictItem= ruleDictItem EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictItemRule());
+ }
+ pushFollow(FOLLOW_ruleDictItem_in_entryRuleDictItem10516);
+ iv_ruleDictItem=ruleDictItem();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictItem;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictItem10526); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictItem"
+
+
+ // $ANTLR start "ruleDictItem"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4893:1: ruleDictItem returns [EObject current=null] : ( () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )? ) ;
+ public final EObject ruleDictItem() throws RecognitionException {
+ EObject current = null;
+
+ Token this_COLON_2=null;
+ Token this_INDENT_4=null;
+ Token this_OUTDENT_6=null;
+ EObject lv_key_1_0 = null;
+
+ EObject lv_value_3_0 = null;
+
+ EObject lv_value_5_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4896:28: ( ( () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4897:1: ( () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4897:1: ( () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4897:2: () ( (lv_key_1_0= ruleDictKey ) ) (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4897:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4898:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getDictItemAccess().getDictItemAction_0(),
+ current);
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4903:2: ( (lv_key_1_0= ruleDictKey ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4904:1: (lv_key_1_0= ruleDictKey )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4904:1: (lv_key_1_0= ruleDictKey )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4905:3: lv_key_1_0= ruleDictKey
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemAccess().getKeyDictKeyParserRuleCall_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleDictKey_in_ruleDictItem10581);
+ lv_key_1_0=ruleDictKey();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ current,
+ "key",
+ lv_key_1_0,
+ "DictKey");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4921:2: (this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) ) )?
+ int alt86=2;
+ int LA86_0 = input.LA(1);
+
+ if ( (LA86_0==RULE_COLON) ) {
+ alt86=1;
+ }
+ switch (alt86) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4921:3: this_COLON_2= RULE_COLON ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) )
+ {
+ this_COLON_2=(Token)match(input,RULE_COLON,FOLLOW_RULE_COLON_in_ruleDictItem10593); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COLON_2, grammarAccess.getDictItemAccess().getCOLONTerminalRuleCall_2_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4925:1: ( ( (lv_value_3_0= ruleExpression ) ) | (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT ) )
+ int alt85=2;
+ int LA85_0 = input.LA(1);
+
+ if ( (LA85_0==RULE_PARAM_START||LA85_0==RULE_FUNC_ARROW||LA85_0==RULE_STRING||(LA85_0>=RULE_FOR && LA85_0<=RULE_WHILE)||LA85_0==RULE_UNTIL||LA85_0==RULE_LBRACKET||(LA85_0>=RULE_PLUS && LA85_0<=RULE_MINUS)||(LA85_0>=RULE_UNARY && LA85_0<=RULE_MINUS_MINUS)||LA85_0==RULE_SUPER||LA85_0==RULE_AT_SIGIL||(LA85_0>=RULE_THIS && LA85_0<=RULE_TRY)||LA85_0==RULE_SWITCH||(LA85_0>=RULE_IF && LA85_0<=RULE_LCURLY)||(LA85_0>=RULE_BOUND_FUNC_ARROW && LA85_0<=RULE_LPAREN)) ) {
+ alt85=1;
+ }
+ else if ( (LA85_0==RULE_INDENT) ) {
+ alt85=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 85, 0, input);
+
+ throw nvae;
+ }
+ switch (alt85) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4925:2: ( (lv_value_3_0= ruleExpression ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4925:2: ( (lv_value_3_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4926:1: (lv_value_3_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4926:1: (lv_value_3_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4927:3: lv_value_3_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleDictItem10614);
+ lv_value_3_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_3_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4944:6: (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4944:6: (this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4944:7: this_INDENT_4= RULE_INDENT ( (lv_value_5_0= ruleExpression ) ) this_OUTDENT_6= RULE_OUTDENT
+ {
+ this_INDENT_4=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleDictItem10632); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_4, grammarAccess.getDictItemAccess().getINDENTTerminalRuleCall_2_1_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4948:1: ( (lv_value_5_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4949:1: (lv_value_5_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4949:1: (lv_value_5_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4950:3: lv_value_5_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictItemAccess().getValueExpressionParserRuleCall_2_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleDictItem10652);
+ lv_value_5_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDictItemRule());
+ }
+ set(
+ current,
+ "value",
+ lv_value_5_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_6=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleDictItem10663); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_6, grammarAccess.getDictItemAccess().getOUTDENTTerminalRuleCall_2_1_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictItem"
+
+
+ // $ANTLR start "entryRuleDictKey"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4978:1: entryRuleDictKey returns [EObject current=null] : iv_ruleDictKey= ruleDictKey EOF ;
+ public final EObject entryRuleDictKey() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDictKey = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4979:2: (iv_ruleDictKey= ruleDictKey EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4980:2: iv_ruleDictKey= ruleDictKey EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getDictKeyRule());
+ }
+ pushFollow(FOLLOW_ruleDictKey_in_entryRuleDictKey10702);
+ iv_ruleDictKey=ruleDictKey();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleDictKey;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDictKey10712); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDictKey"
+
+
+ // $ANTLR start "ruleDictKey"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4987:1: ruleDictKey returns [EObject current=null] : (this_Literal_0= ruleLiteral | this_Id_1= ruleId ) ;
+ public final EObject ruleDictKey() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_Literal_0 = null;
+
+ EObject this_Id_1 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4990:28: ( (this_Literal_0= ruleLiteral | this_Id_1= ruleId ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4991:1: (this_Literal_0= ruleLiteral | this_Id_1= ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4991:1: (this_Literal_0= ruleLiteral | this_Id_1= ruleId )
+ int alt87=2;
+ int LA87_0 = input.LA(1);
+
+ if ( (LA87_0==RULE_STRING||(LA87_0>=RULE_NUMBER && LA87_0<=RULE_REGEX)) ) {
+ alt87=1;
+ }
+ else if ( (LA87_0==RULE_IDENTIFIER) ) {
+ alt87=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 87, 0, input);
+
+ throw nvae;
+ }
+ switch (alt87) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4992:5: this_Literal_0= ruleLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictKeyAccess().getLiteralParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleLiteral_in_ruleDictKey10759);
+ this_Literal_0=ruleLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Literal_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5002:5: this_Id_1= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getDictKeyAccess().getIdParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleDictKey10786);
+ this_Id_1=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDictKey"
+
+
+ // $ANTLR start "entryRuleLambda"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5018:1: entryRuleLambda returns [EObject current=null] : iv_ruleLambda= ruleLambda EOF ;
+ public final EObject entryRuleLambda() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleLambda = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5019:2: (iv_ruleLambda= ruleLambda EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5020:2: iv_ruleLambda= ruleLambda EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getLambdaRule());
+ }
+ pushFollow(FOLLOW_ruleLambda_in_entryRuleLambda10821);
+ iv_ruleLambda=ruleLambda();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleLambda;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLambda10831); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleLambda"
+
+
+ // $ANTLR start "ruleLambda"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5027:1: ruleLambda returns [EObject current=null] : ( (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) ) ) ;
+ public final EObject ruleLambda() throws RecognitionException {
+ EObject current = null;
+
+ Token this_PARAM_START_0=null;
+ Token this_COMMA_2=null;
+ Token this_PARAM_END_4=null;
+ Token this_FUNC_ARROW_5=null;
+ Token this_BOUND_FUNC_ARROW_6=null;
+ EObject lv_params_1_0 = null;
+
+ EObject lv_params_3_0 = null;
+
+ EObject lv_body_7_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5030:28: ( ( (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5031:1: ( (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5031:1: ( (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5031:2: (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )? (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW ) ( (lv_body_7_0= ruleBlock ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5031:2: (this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END )?
+ int alt90=2;
+ int LA90_0 = input.LA(1);
+
+ if ( (LA90_0==RULE_PARAM_START) ) {
+ alt90=1;
+ }
+ switch (alt90) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5031:3: this_PARAM_START_0= RULE_PARAM_START ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )? this_PARAM_END_4= RULE_PARAM_END
+ {
+ this_PARAM_START_0=(Token)match(input,RULE_PARAM_START,FOLLOW_RULE_PARAM_START_in_ruleLambda10868); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PARAM_START_0, grammarAccess.getLambdaAccess().getPARAM_STARTTerminalRuleCall_0_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5035:1: ( ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )* )?
+ int alt89=2;
+ int LA89_0 = input.LA(1);
+
+ if ( (LA89_0==RULE_LBRACKET||LA89_0==RULE_AT_SIGIL||(LA89_0>=RULE_IDENTIFIER && LA89_0<=RULE_LCURLY)) ) {
+ alt89=1;
+ }
+ switch (alt89) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5035:2: ( (lv_params_1_0= ruleParam ) ) (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )*
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5035:2: ( (lv_params_1_0= ruleParam ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5036:1: (lv_params_1_0= ruleParam )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5036:1: (lv_params_1_0= ruleParam )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5037:3: lv_params_1_0= ruleParam
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleParam_in_ruleLambda10889);
+ lv_params_1_0=ruleParam();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ add(
+ current,
+ "params",
+ lv_params_1_0,
+ "Param");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5053:2: (this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) ) )*
+ loop88:
+ do {
+ int alt88=2;
+ int LA88_0 = input.LA(1);
+
+ if ( (LA88_0==RULE_COMMA) ) {
+ alt88=1;
+ }
+
+
+ switch (alt88) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5053:3: this_COMMA_2= RULE_COMMA ( (lv_params_3_0= ruleParam ) )
+ {
+ this_COMMA_2=(Token)match(input,RULE_COMMA,FOLLOW_RULE_COMMA_in_ruleLambda10901); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_COMMA_2, grammarAccess.getLambdaAccess().getCOMMATerminalRuleCall_0_1_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5057:1: ( (lv_params_3_0= ruleParam ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5058:1: (lv_params_3_0= ruleParam )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5058:1: (lv_params_3_0= ruleParam )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5059:3: lv_params_3_0= ruleParam
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLambdaAccess().getParamsParamParserRuleCall_0_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleParam_in_ruleLambda10921);
+ lv_params_3_0=ruleParam();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ add(
+ current,
+ "params",
+ lv_params_3_0,
+ "Param");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop88;
+ }
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+ this_PARAM_END_4=(Token)match(input,RULE_PARAM_END,FOLLOW_RULE_PARAM_END_in_ruleLambda10936); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_PARAM_END_4, grammarAccess.getLambdaAccess().getPARAM_ENDTerminalRuleCall_0_2());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5079:3: (this_FUNC_ARROW_5= RULE_FUNC_ARROW | this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW )
+ int alt91=2;
+ int LA91_0 = input.LA(1);
+
+ if ( (LA91_0==RULE_FUNC_ARROW) ) {
+ alt91=1;
+ }
+ else if ( (LA91_0==RULE_BOUND_FUNC_ARROW) ) {
+ alt91=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 91, 0, input);
+
+ throw nvae;
+ }
+ switch (alt91) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5079:4: this_FUNC_ARROW_5= RULE_FUNC_ARROW
+ {
+ this_FUNC_ARROW_5=(Token)match(input,RULE_FUNC_ARROW,FOLLOW_RULE_FUNC_ARROW_in_ruleLambda10949); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_FUNC_ARROW_5, grammarAccess.getLambdaAccess().getFUNC_ARROWTerminalRuleCall_1_0());
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5084:6: this_BOUND_FUNC_ARROW_6= RULE_BOUND_FUNC_ARROW
+ {
+ this_BOUND_FUNC_ARROW_6=(Token)match(input,RULE_BOUND_FUNC_ARROW,FOLLOW_RULE_BOUND_FUNC_ARROW_in_ruleLambda10965); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_BOUND_FUNC_ARROW_6, grammarAccess.getLambdaAccess().getBOUND_FUNC_ARROWTerminalRuleCall_1_1());
+
+ }
+
+ }
+ break;
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5088:2: ( (lv_body_7_0= ruleBlock ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5089:1: (lv_body_7_0= ruleBlock )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5089:1: (lv_body_7_0= ruleBlock )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5090:3: lv_body_7_0= ruleBlock
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLambdaAccess().getBodyBlockParserRuleCall_2_0());
+
+ }
+ pushFollow(FOLLOW_ruleBlock_in_ruleLambda10986);
+ lv_body_7_0=ruleBlock();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getLambdaRule());
+ }
+ set(
+ current,
+ "body",
+ lv_body_7_0,
+ "Block");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleLambda"
+
+
+ // $ANTLR start "entryRuleParam"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5114:1: entryRuleParam returns [EObject current=null] : iv_ruleParam= ruleParam EOF ;
+ public final EObject entryRuleParam() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleParam = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5115:2: (iv_ruleParam= ruleParam EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5116:2: iv_ruleParam= ruleParam EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getParamRule());
+ }
+ pushFollow(FOLLOW_ruleParam_in_entryRuleParam11022);
+ iv_ruleParam=ruleParam();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleParam;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleParam11032); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleParam"
+
+
+ // $ANTLR start "ruleParam"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5123:1: ruleParam returns [EObject current=null] : ( (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )? ) ;
+ public final EObject ruleParam() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_splat_4_0=null;
+ Token this_EQUAL_5=null;
+ EObject this_Id_0 = null;
+
+ EObject this_Array_1 = null;
+
+ EObject this_Dictionary_2 = null;
+
+ EObject this_ThisProperty_3 = null;
+
+ EObject lv_defaultValue_6_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5126:28: ( ( (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )? ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5127:1: ( (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )? )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5127:1: ( (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )? )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5127:2: (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty ) ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )?
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5127:2: (this_Id_0= ruleId | ( ( RULE_LBRACKET )=>this_Array_1= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary ) | this_ThisProperty_3= ruleThisProperty )
+ int alt92=4;
+ int LA92_0 = input.LA(1);
+
+ if ( (LA92_0==RULE_IDENTIFIER) ) {
+ alt92=1;
+ }
+ else if ( (LA92_0==RULE_LBRACKET) && (synpred36_InternalCakefile())) {
+ alt92=2;
+ }
+ else if ( (LA92_0==RULE_LCURLY) && (synpred37_InternalCakefile())) {
+ alt92=3;
+ }
+ else if ( (LA92_0==RULE_AT_SIGIL) ) {
+ alt92=4;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 92, 0, input);
+
+ throw nvae;
+ }
+ switch (alt92) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5128:5: this_Id_0= ruleId
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getIdParserRuleCall_0_0());
+
+ }
+ pushFollow(FOLLOW_ruleId_in_ruleParam11080);
+ this_Id_0=ruleId();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Id_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5137:6: ( ( RULE_LBRACKET )=>this_Array_1= ruleArray )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5137:6: ( ( RULE_LBRACKET )=>this_Array_1= ruleArray )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5137:7: ( RULE_LBRACKET )=>this_Array_1= ruleArray
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getArrayParserRuleCall_0_1());
+
+ }
+ pushFollow(FOLLOW_ruleArray_in_ruleParam11113);
+ this_Array_1=ruleArray();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Array_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5147:6: ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5147:6: ( ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5147:7: ( RULE_LCURLY )=>this_Dictionary_2= ruleDictionary
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getDictionaryParserRuleCall_0_2());
+
+ }
+ pushFollow(FOLLOW_ruleDictionary_in_ruleParam11147);
+ this_Dictionary_2=ruleDictionary();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_Dictionary_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5158:5: this_ThisProperty_3= ruleThisProperty
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getThisPropertyParserRuleCall_0_3());
+
+ }
+ pushFollow(FOLLOW_ruleThisProperty_in_ruleParam11175);
+ this_ThisProperty_3=ruleThisProperty();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_ThisProperty_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5166:2: ( ( (lv_splat_4_0= RULE_ELLIPSIS ) ) | (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) ) )?
+ int alt93=3;
+ int LA93_0 = input.LA(1);
+
+ if ( (LA93_0==RULE_ELLIPSIS) ) {
+ alt93=1;
+ }
+ else if ( (LA93_0==RULE_EQUAL) ) {
+ alt93=2;
+ }
+ switch (alt93) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5166:3: ( (lv_splat_4_0= RULE_ELLIPSIS ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5166:3: ( (lv_splat_4_0= RULE_ELLIPSIS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5167:1: (lv_splat_4_0= RULE_ELLIPSIS )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5167:1: (lv_splat_4_0= RULE_ELLIPSIS )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5168:3: lv_splat_4_0= RULE_ELLIPSIS
+ {
+ lv_splat_4_0=(Token)match(input,RULE_ELLIPSIS,FOLLOW_RULE_ELLIPSIS_in_ruleParam11193); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_splat_4_0, grammarAccess.getParamAccess().getSplatELLIPSISTerminalRuleCall_1_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getParamRule());
+ }
+ setWithLastConsumed(
+ current,
+ "splat",
+ true,
+ "ELLIPSIS");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5185:6: (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5185:6: (this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5185:7: this_EQUAL_5= RULE_EQUAL ( (lv_defaultValue_6_0= ruleExpression ) )
+ {
+ this_EQUAL_5=(Token)match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_ruleParam11216); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_EQUAL_5, grammarAccess.getParamAccess().getEQUALTerminalRuleCall_1_1_0());
+
+ }
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5189:1: ( (lv_defaultValue_6_0= ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5190:1: (lv_defaultValue_6_0= ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5190:1: (lv_defaultValue_6_0= ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5191:3: lv_defaultValue_6_0= ruleExpression
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParamAccess().getDefaultValueExpressionParserRuleCall_1_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleExpression_in_ruleParam11236);
+ lv_defaultValue_6_0=ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getParamRule());
+ }
+ set(
+ current,
+ "defaultValue",
+ lv_defaultValue_6_0,
+ "Expression");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleParam"
+
+
+ // $ANTLR start "entryRuleNumberLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5215:1: entryRuleNumberLiteral returns [EObject current=null] : iv_ruleNumberLiteral= ruleNumberLiteral EOF ;
+ public final EObject entryRuleNumberLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleNumberLiteral = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5216:2: (iv_ruleNumberLiteral= ruleNumberLiteral EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5217:2: iv_ruleNumberLiteral= ruleNumberLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getNumberLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleNumberLiteral_in_entryRuleNumberLiteral11275);
+ iv_ruleNumberLiteral=ruleNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleNumberLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleNumberLiteral11285); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleNumberLiteral"
+
+
+ // $ANTLR start "ruleNumberLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5224:1: ruleNumberLiteral returns [EObject current=null] : ( () this_NUMBER_1= RULE_NUMBER ) ;
+ public final EObject ruleNumberLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_NUMBER_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5227:28: ( ( () this_NUMBER_1= RULE_NUMBER ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5228:1: ( () this_NUMBER_1= RULE_NUMBER )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5228:1: ( () this_NUMBER_1= RULE_NUMBER )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5228:2: () this_NUMBER_1= RULE_NUMBER
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5228:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5229:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getNumberLiteralAccess().getNumberLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_NUMBER_1=(Token)match(input,RULE_NUMBER,FOLLOW_RULE_NUMBER_in_ruleNumberLiteral11330); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_NUMBER_1, grammarAccess.getNumberLiteralAccess().getNUMBERTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleNumberLiteral"
+
+
+ // $ANTLR start "entryRuleStringLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5246:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ;
+ public final EObject entryRuleStringLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleStringLiteral = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5247:2: (iv_ruleStringLiteral= ruleStringLiteral EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5248:2: iv_ruleStringLiteral= ruleStringLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getStringLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_entryRuleStringLiteral11365);
+ iv_ruleStringLiteral=ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleStringLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleStringLiteral11375); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleStringLiteral"
+
+
+ // $ANTLR start "ruleStringLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5255:1: ruleStringLiteral returns [EObject current=null] : ( () this_STRING_1= RULE_STRING ) ;
+ public final EObject ruleStringLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_STRING_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5258:28: ( ( () this_STRING_1= RULE_STRING ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5259:1: ( () this_STRING_1= RULE_STRING )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5259:1: ( () this_STRING_1= RULE_STRING )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5259:2: () this_STRING_1= RULE_STRING
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5259:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5260:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getStringLiteralAccess().getStringLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_STRING_1=(Token)match(input,RULE_STRING,FOLLOW_RULE_STRING_in_ruleStringLiteral11420); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_STRING_1, grammarAccess.getStringLiteralAccess().getSTRINGTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleStringLiteral"
+
+
+ // $ANTLR start "entryRuleBoolLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5277:1: entryRuleBoolLiteral returns [EObject current=null] : iv_ruleBoolLiteral= ruleBoolLiteral EOF ;
+ public final EObject entryRuleBoolLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleBoolLiteral = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5278:2: (iv_ruleBoolLiteral= ruleBoolLiteral EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5279:2: iv_ruleBoolLiteral= ruleBoolLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getBoolLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleBoolLiteral_in_entryRuleBoolLiteral11455);
+ iv_ruleBoolLiteral=ruleBoolLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleBoolLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBoolLiteral11465); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleBoolLiteral"
+
+
+ // $ANTLR start "ruleBoolLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5286:1: ruleBoolLiteral returns [EObject current=null] : ( () this_BOOL_1= RULE_BOOL ) ;
+ public final EObject ruleBoolLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_BOOL_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5289:28: ( ( () this_BOOL_1= RULE_BOOL ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5290:1: ( () this_BOOL_1= RULE_BOOL )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5290:1: ( () this_BOOL_1= RULE_BOOL )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5290:2: () this_BOOL_1= RULE_BOOL
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5290:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5291:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getBoolLiteralAccess().getBoolLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_BOOL_1=(Token)match(input,RULE_BOOL,FOLLOW_RULE_BOOL_in_ruleBoolLiteral11510); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_BOOL_1, grammarAccess.getBoolLiteralAccess().getBOOLTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleBoolLiteral"
+
+
+ // $ANTLR start "entryRuleJSLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5308:1: entryRuleJSLiteral returns [EObject current=null] : iv_ruleJSLiteral= ruleJSLiteral EOF ;
+ public final EObject entryRuleJSLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleJSLiteral = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5309:2: (iv_ruleJSLiteral= ruleJSLiteral EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5310:2: iv_ruleJSLiteral= ruleJSLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getJSLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleJSLiteral_in_entryRuleJSLiteral11545);
+ iv_ruleJSLiteral=ruleJSLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleJSLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleJSLiteral11555); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleJSLiteral"
+
+
+ // $ANTLR start "ruleJSLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5317:1: ruleJSLiteral returns [EObject current=null] : ( () this_JS_1= RULE_JS ) ;
+ public final EObject ruleJSLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_JS_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5320:28: ( ( () this_JS_1= RULE_JS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5321:1: ( () this_JS_1= RULE_JS )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5321:1: ( () this_JS_1= RULE_JS )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5321:2: () this_JS_1= RULE_JS
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5321:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5322:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getJSLiteralAccess().getJSLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_JS_1=(Token)match(input,RULE_JS,FOLLOW_RULE_JS_in_ruleJSLiteral11600); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_JS_1, grammarAccess.getJSLiteralAccess().getJSTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleJSLiteral"
+
+
+ // $ANTLR start "entryRuleRegexLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5339:1: entryRuleRegexLiteral returns [EObject current=null] : iv_ruleRegexLiteral= ruleRegexLiteral EOF ;
+ public final EObject entryRuleRegexLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRegexLiteral = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5340:2: (iv_ruleRegexLiteral= ruleRegexLiteral EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5341:2: iv_ruleRegexLiteral= ruleRegexLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getRegexLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleRegexLiteral_in_entryRuleRegexLiteral11635);
+ iv_ruleRegexLiteral=ruleRegexLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleRegexLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRegexLiteral11645); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRegexLiteral"
+
+
+ // $ANTLR start "ruleRegexLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5348:1: ruleRegexLiteral returns [EObject current=null] : ( () this_REGEX_1= RULE_REGEX ) ;
+ public final EObject ruleRegexLiteral() throws RecognitionException {
+ EObject current = null;
+
+ Token this_REGEX_1=null;
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5351:28: ( ( () this_REGEX_1= RULE_REGEX ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5352:1: ( () this_REGEX_1= RULE_REGEX )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5352:1: ( () this_REGEX_1= RULE_REGEX )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5352:2: () this_REGEX_1= RULE_REGEX
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5352:2: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5353:5:
+ {
+ if ( state.backtracking==0 ) {
+
+ current = forceCreateModelElement(
+ grammarAccess.getRegexLiteralAccess().getRegexLiteralAction_0(),
+ current);
+
+ }
+
+ }
+
+ this_REGEX_1=(Token)match(input,RULE_REGEX,FOLLOW_RULE_REGEX_in_ruleRegexLiteral11690); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_REGEX_1, grammarAccess.getRegexLiteralAccess().getREGEXTerminalRuleCall_1());
+
+ }
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRegexLiteral"
+
+
+ // $ANTLR start "entryRuleLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5370:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
+ public final EObject entryRuleLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleLiteral = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5371:2: (iv_ruleLiteral= ruleLiteral EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5372:2: iv_ruleLiteral= ruleLiteral EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getLiteralRule());
+ }
+ pushFollow(FOLLOW_ruleLiteral_in_entryRuleLiteral11725);
+ iv_ruleLiteral=ruleLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleLiteral;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleLiteral11735); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleLiteral"
+
+
+ // $ANTLR start "ruleLiteral"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5379:1: ruleLiteral returns [EObject current=null] : (this_NumberLiteral_0= ruleNumberLiteral | this_StringLiteral_1= ruleStringLiteral | this_BoolLiteral_2= ruleBoolLiteral | this_JSLiteral_3= ruleJSLiteral | this_RegexLiteral_4= ruleRegexLiteral ) ;
+ public final EObject ruleLiteral() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_NumberLiteral_0 = null;
+
+ EObject this_StringLiteral_1 = null;
+
+ EObject this_BoolLiteral_2 = null;
+
+ EObject this_JSLiteral_3 = null;
+
+ EObject this_RegexLiteral_4 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5382:28: ( (this_NumberLiteral_0= ruleNumberLiteral | this_StringLiteral_1= ruleStringLiteral | this_BoolLiteral_2= ruleBoolLiteral | this_JSLiteral_3= ruleJSLiteral | this_RegexLiteral_4= ruleRegexLiteral ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5383:1: (this_NumberLiteral_0= ruleNumberLiteral | this_StringLiteral_1= ruleStringLiteral | this_BoolLiteral_2= ruleBoolLiteral | this_JSLiteral_3= ruleJSLiteral | this_RegexLiteral_4= ruleRegexLiteral )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5383:1: (this_NumberLiteral_0= ruleNumberLiteral | this_StringLiteral_1= ruleStringLiteral | this_BoolLiteral_2= ruleBoolLiteral | this_JSLiteral_3= ruleJSLiteral | this_RegexLiteral_4= ruleRegexLiteral )
+ int alt94=5;
+ switch ( input.LA(1) ) {
+ case RULE_NUMBER:
+ {
+ alt94=1;
+ }
+ break;
+ case RULE_STRING:
+ {
+ alt94=2;
+ }
+ break;
+ case RULE_BOOL:
+ {
+ alt94=3;
+ }
+ break;
+ case RULE_JS:
+ {
+ alt94=4;
+ }
+ break;
+ case RULE_REGEX:
+ {
+ alt94=5;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 94, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt94) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5384:5: this_NumberLiteral_0= ruleNumberLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_0());
+
+ }
+ pushFollow(FOLLOW_ruleNumberLiteral_in_ruleLiteral11782);
+ this_NumberLiteral_0=ruleNumberLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_NumberLiteral_0;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5394:5: this_StringLiteral_1= ruleStringLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_1());
+
+ }
+ pushFollow(FOLLOW_ruleStringLiteral_in_ruleLiteral11809);
+ this_StringLiteral_1=ruleStringLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_StringLiteral_1;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 3 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5404:5: this_BoolLiteral_2= ruleBoolLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getBoolLiteralParserRuleCall_2());
+
+ }
+ pushFollow(FOLLOW_ruleBoolLiteral_in_ruleLiteral11836);
+ this_BoolLiteral_2=ruleBoolLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_BoolLiteral_2;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 4 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5414:5: this_JSLiteral_3= ruleJSLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getJSLiteralParserRuleCall_3());
+
+ }
+ pushFollow(FOLLOW_ruleJSLiteral_in_ruleLiteral11863);
+ this_JSLiteral_3=ruleJSLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_JSLiteral_3;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+ case 5 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5424:5: this_RegexLiteral_4= ruleRegexLiteral
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getLiteralAccess().getRegexLiteralParserRuleCall_4());
+
+ }
+ pushFollow(FOLLOW_ruleRegexLiteral_in_ruleLiteral11890);
+ this_RegexLiteral_4=ruleRegexLiteral();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = this_RegexLiteral_4;
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleLiteral"
+
+
+ // $ANTLR start "entryRuleParenthetical"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5440:1: entryRuleParenthetical returns [EObject current=null] : iv_ruleParenthetical= ruleParenthetical EOF ;
+ public final EObject entryRuleParenthetical() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleParenthetical = null;
+
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5441:2: (iv_ruleParenthetical= ruleParenthetical EOF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5442:2: iv_ruleParenthetical= ruleParenthetical EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getParentheticalRule());
+ }
+ pushFollow(FOLLOW_ruleParenthetical_in_entryRuleParenthetical11925);
+ iv_ruleParenthetical=ruleParenthetical();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleParenthetical;
+ }
+ match(input,EOF,FOLLOW_EOF_in_entryRuleParenthetical11935); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleParenthetical"
+
+
+ // $ANTLR start "ruleParenthetical"
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5449:1: ruleParenthetical returns [EObject current=null] : ( ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) ) ;
+ public final EObject ruleParenthetical() throws RecognitionException {
+ EObject current = null;
+
+ Token this_LPAREN_0=null;
+ Token this_INDENT_1=null;
+ Token this_OUTDENT_3=null;
+ Token this_RPAREN_4=null;
+ Token this_LPAREN_5=null;
+ Token this_RPAREN_7=null;
+ EObject lv_content_2_0 = null;
+
+ EObject lv_content_6_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5452:28: ( ( ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:1: ( ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:1: ( ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) )
+ int alt95=2;
+ alt95 = dfa95.predict(input);
+ switch (alt95) {
+ case 1 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:2: ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:2: ( ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:3: ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:3: ( ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:4: ( ( RULE_LPAREN RULE_INDENT ) )=> (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:34: (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:35: this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT
+ {
+ this_LPAREN_0=(Token)match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_ruleParenthetical11983); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LPAREN_0, grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_0_0_0_0());
+
+ }
+ this_INDENT_1=(Token)match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_ruleParenthetical11993); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_INDENT_1, grammarAccess.getParentheticalAccess().getINDENTTerminalRuleCall_0_0_0_1());
+
+ }
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5461:3: ( (lv_content_2_0= ruleBody ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5462:1: (lv_content_2_0= ruleBody )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5462:1: (lv_content_2_0= ruleBody )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5463:3: lv_content_2_0= ruleBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_0_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBody_in_ruleParenthetical12015);
+ lv_content_2_0=ruleBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getParentheticalRule());
+ }
+ set(
+ current,
+ "content",
+ lv_content_2_0,
+ "Body");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_OUTDENT_3=(Token)match(input,RULE_OUTDENT,FOLLOW_RULE_OUTDENT_in_ruleParenthetical12026); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_OUTDENT_3, grammarAccess.getParentheticalAccess().getOUTDENTTerminalRuleCall_0_2());
+
+ }
+ this_RPAREN_4=(Token)match(input,RULE_RPAREN,FOLLOW_RULE_RPAREN_in_ruleParenthetical12036); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RPAREN_4, grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_0_3());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5488:6: ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5488:6: ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5488:7: ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5488:7: ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5488:8: ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN
+ {
+ this_LPAREN_5=(Token)match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_ruleParenthetical12060); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_LPAREN_5, grammarAccess.getParentheticalAccess().getLPARENTerminalRuleCall_1_0());
+
+ }
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5492:2: ( (lv_content_6_0= ruleBody ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5493:1: (lv_content_6_0= ruleBody )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5493:1: (lv_content_6_0= ruleBody )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5494:3: lv_content_6_0= ruleBody
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getParentheticalAccess().getContentBodyParserRuleCall_1_1_0());
+
+ }
+ pushFollow(FOLLOW_ruleBody_in_ruleParenthetical12081);
+ lv_content_6_0=ruleBody();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getParentheticalRule());
+ }
+ set(
+ current,
+ "content",
+ lv_content_6_0,
+ "Body");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+
+ this_RPAREN_7=(Token)match(input,RULE_RPAREN,FOLLOW_RULE_RPAREN_in_ruleParenthetical12092); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(this_RPAREN_7, grammarAccess.getParentheticalAccess().getRPARENTerminalRuleCall_1_2());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+ leaveRule();
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleParenthetical"
+
+ // $ANTLR start synpred1_InternalCakefile
+ public final void synpred1_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:371:7: ( ( ( ( ruleId ) ) RULE_EQUAL 'require' ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:371:8: ( ( ( ruleId ) ) RULE_EQUAL 'require' )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:371:8: ( ( ( ruleId ) ) RULE_EQUAL 'require' )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:371:9: ( ( ruleId ) ) RULE_EQUAL 'require'
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:371:9: ( ( ruleId ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:372:1: ( ruleId )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:372:1: ( ruleId )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:373:1: ruleId
+ {
+ pushFollow(FOLLOW_ruleId_in_synpred1_InternalCakefile767);
+ ruleId();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ match(input,RULE_EQUAL,FOLLOW_RULE_EQUAL_in_synpred1_InternalCakefile773); if (state.failed) return ;
+ match(input,86,FOLLOW_86_in_synpred1_InternalCakefile775); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred1_InternalCakefile
+
+ // $ANTLR start synpred3_InternalCakefile
+ public final void synpred3_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1070:4: ( RULE_POST_IF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1070:6: RULE_POST_IF
+ {
+ match(input,RULE_POST_IF,FOLLOW_RULE_POST_IF_in_synpred3_InternalCakefile2248); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred3_InternalCakefile
+
+ // $ANTLR start synpred4_InternalCakefile
+ public final void synpred4_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1099:8: ( RULE_FOR )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1099:10: RULE_FOR
+ {
+ match(input,RULE_FOR,FOLLOW_RULE_FOR_in_synpred4_InternalCakefile2303); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred4_InternalCakefile
+
+ // $ANTLR start synpred5_InternalCakefile
+ public final void synpred5_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1128:8: ( RULE_WHILE )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1128:10: RULE_WHILE
+ {
+ match(input,RULE_WHILE,FOLLOW_RULE_WHILE_in_synpred5_InternalCakefile2358); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred5_InternalCakefile
+
+ // $ANTLR start synpred6_InternalCakefile
+ public final void synpred6_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1156:4: ( RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1156:6: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred6_InternalCakefile2406); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred6_InternalCakefile
+
+ // $ANTLR start synpred7_InternalCakefile
+ public final void synpred7_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1179:8: ( RULE_UNTIL )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1179:10: RULE_UNTIL
+ {
+ match(input,RULE_UNTIL,FOLLOW_RULE_UNTIL_in_synpred7_InternalCakefile2454); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred7_InternalCakefile
+
+ // $ANTLR start synpred8_InternalCakefile
+ public final void synpred8_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1207:4: ( RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1207:6: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred8_InternalCakefile2502); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred8_InternalCakefile
+
+ // $ANTLR start synpred9_InternalCakefile
+ public final void synpred9_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1369:5: ( RULE_FOROF )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1369:7: RULE_FOROF
+ {
+ match(input,RULE_FOROF,FOLLOW_RULE_FOROF_in_synpred9_InternalCakefile2877); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred9_InternalCakefile
+
+ // $ANTLR start synpred10_InternalCakefile
+ public final void synpred10_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1391:4: ( RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1391:6: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred10_InternalCakefile2916); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred10_InternalCakefile
+
+ // $ANTLR start synpred11_InternalCakefile
+ public final void synpred11_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1414:8: ( RULE_FORIN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1414:10: RULE_FORIN
+ {
+ match(input,RULE_FORIN,FOLLOW_RULE_FORIN_in_synpred11_InternalCakefile2964); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred11_InternalCakefile
+
+ // $ANTLR start synpred12_InternalCakefile
+ public final void synpred12_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1436:5: ( RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1436:7: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred12_InternalCakefile3004); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred12_InternalCakefile
+
+ // $ANTLR start synpred13_InternalCakefile
+ public final void synpred13_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1458:4: ( RULE_BY )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1458:6: RULE_BY
+ {
+ match(input,RULE_BY,FOLLOW_RULE_BY_in_synpred13_InternalCakefile3043); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred13_InternalCakefile
+
+ // $ANTLR start synpred14_InternalCakefile
+ public final void synpred14_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1481:8: ( RULE_BY )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1481:10: RULE_BY
+ {
+ match(input,RULE_BY,FOLLOW_RULE_BY_in_synpred14_InternalCakefile3091); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred14_InternalCakefile
+
+ // $ANTLR start synpred15_InternalCakefile
+ public final void synpred15_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1503:4: ( RULE_WHEN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1503:6: RULE_WHEN
+ {
+ match(input,RULE_WHEN,FOLLOW_RULE_WHEN_in_synpred15_InternalCakefile3130); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred15_InternalCakefile
+
+ // $ANTLR start synpred17_InternalCakefile
+ public final void synpred17_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:4: ( ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:5: ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:5: ( ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:6: ( ( ruleAssignable ) ) ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1625:6: ( ( ruleAssignable ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1626:1: ( ruleAssignable )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1626:1: ( ruleAssignable )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1627:1: ruleAssignable
+ {
+ pushFollow(FOLLOW_ruleAssignable_in_synpred17_InternalCakefile3444);
+ ruleAssignable();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1629:2: ( ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1630:1: ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1630:1: ( ( RULE_EQUAL | RULE_COMPOUND_ASSIGN ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1631:1: ( RULE_EQUAL | RULE_COMPOUND_ASSIGN )
+ {
+ if ( input.LA(1)==RULE_EQUAL||input.LA(1)==RULE_COMPOUND_ASSIGN ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred17_InternalCakefile
+
+ // $ANTLR start synpred18_InternalCakefile
+ public final void synpred18_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1809:3: ( ( () ( ( RULE_LOGIC ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1809:4: ( () ( ( RULE_LOGIC ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1809:4: ( () ( ( RULE_LOGIC ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1809:5: () ( ( RULE_LOGIC ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1809:5: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1810:1:
+ {
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1810:2: ( ( RULE_LOGIC ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1811:1: ( RULE_LOGIC )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1811:1: ( RULE_LOGIC )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1812:1: RULE_LOGIC
+ {
+ match(input,RULE_LOGIC,FOLLOW_RULE_LOGIC_in_synpred18_InternalCakefile3868); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred18_InternalCakefile
+
+ // $ANTLR start synpred19_InternalCakefile
+ public final void synpred19_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1887:3: ( ( () ( ( RULE_COMPARE ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1887:4: ( () ( ( RULE_COMPARE ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1887:4: ( () ( ( RULE_COMPARE ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1887:5: () ( ( RULE_COMPARE ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1887:5: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1888:1:
+ {
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1888:2: ( ( RULE_COMPARE ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1889:1: ( RULE_COMPARE )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1889:1: ( RULE_COMPARE )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1890:1: RULE_COMPARE
+ {
+ match(input,RULE_COMPARE,FOLLOW_RULE_COMPARE_in_synpred19_InternalCakefile4037); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred19_InternalCakefile
+
+ // $ANTLR start synpred20_InternalCakefile
+ public final void synpred20_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1965:3: ( ( () ( ( RULE_RELATION ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1965:4: ( () ( ( RULE_RELATION ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1965:4: ( () ( ( RULE_RELATION ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1965:5: () ( ( RULE_RELATION ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1965:5: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1966:1:
+ {
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1966:2: ( ( RULE_RELATION ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1967:1: ( RULE_RELATION )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1967:1: ( RULE_RELATION )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:1968:1: RULE_RELATION
+ {
+ match(input,RULE_RELATION,FOLLOW_RULE_RELATION_in_synpred20_InternalCakefile4206); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred20_InternalCakefile
+
+ // $ANTLR start synpred21_InternalCakefile
+ public final void synpred21_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2043:3: ( ( () ( ( RULE_SHIFT ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2043:4: ( () ( ( RULE_SHIFT ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2043:4: ( () ( ( RULE_SHIFT ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2043:5: () ( ( RULE_SHIFT ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2043:5: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2044:1:
+ {
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2044:2: ( ( RULE_SHIFT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2045:1: ( RULE_SHIFT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2045:1: ( RULE_SHIFT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2046:1: RULE_SHIFT
+ {
+ match(input,RULE_SHIFT,FOLLOW_RULE_SHIFT_in_synpred21_InternalCakefile4375); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred21_InternalCakefile
+
+ // $ANTLR start synpred22_InternalCakefile
+ public final void synpred22_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2121:3: ( ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2121:4: ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2121:4: ( () ( ( ( RULE_PLUS | RULE_MINUS ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2121:5: () ( ( ( RULE_PLUS | RULE_MINUS ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2121:5: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2122:1:
+ {
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2122:2: ( ( ( RULE_PLUS | RULE_MINUS ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2123:1: ( ( RULE_PLUS | RULE_MINUS ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2123:1: ( ( RULE_PLUS | RULE_MINUS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2124:1: ( RULE_PLUS | RULE_MINUS )
+ {
+ if ( (input.LA(1)>=RULE_PLUS && input.LA(1)<=RULE_MINUS) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred22_InternalCakefile
+
+ // $ANTLR start synpred23_InternalCakefile
+ public final void synpred23_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2222:3: ( ( () ( ( RULE_MATH ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2222:4: ( () ( ( RULE_MATH ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2222:4: ( () ( ( RULE_MATH ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2222:5: () ( ( RULE_MATH ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2222:5: ()
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2223:1:
+ {
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2223:2: ( ( RULE_MATH ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2224:1: ( RULE_MATH )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2224:1: ( RULE_MATH )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2225:1: RULE_MATH
+ {
+ match(input,RULE_MATH,FOLLOW_RULE_MATH_in_synpred23_InternalCakefile4753); if (state.failed) return ;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred23_InternalCakefile
+
+ // $ANTLR start synpred24_InternalCakefile
+ public final void synpred24_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2792:4: ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2793:1: ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2793:1: ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2794:1: ( RULE_DOT_DOT | RULE_ELLIPSIS )
+ {
+ if ( (input.LA(1)>=RULE_DOT_DOT && input.LA(1)<=RULE_ELLIPSIS) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred24_InternalCakefile
+
+ // $ANTLR start synpred25_InternalCakefile
+ public final void synpred25_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:8: ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:9: ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:9: ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:10: ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2857:10: ( ( ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2858:1: ( ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2858:1: ( ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2859:1: ruleExpression
+ {
+ pushFollow(FOLLOW_ruleExpression_in_synpred25_InternalCakefile6205);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2861:2: ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2862:1: ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2862:1: ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:2863:1: ( RULE_DOT_DOT | RULE_ELLIPSIS )
+ {
+ if ( (input.LA(1)>=RULE_DOT_DOT && input.LA(1)<=RULE_ELLIPSIS) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred25_InternalCakefile
+
+ // $ANTLR start synpred26_InternalCakefile
+ public final void synpred26_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3013:7: ( ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3013:8: ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3013:8: ( RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3013:10: RULE_LBRACKET ( ( ruleExpression ) ) ( RULE_DOT_DOT | RULE_ELLIPSIS )
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_synpred26_InternalCakefile6515); if (state.failed) return ;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3013:23: ( ( ruleExpression ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3014:1: ( ruleExpression )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3014:1: ( ruleExpression )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3015:1: ruleExpression
+ {
+ pushFollow(FOLLOW_ruleExpression_in_synpred26_InternalCakefile6520);
+ ruleExpression();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+
+ }
+
+ if ( (input.LA(1)>=RULE_DOT_DOT && input.LA(1)<=RULE_ELLIPSIS) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred26_InternalCakefile
+
+ // $ANTLR start synpred27_InternalCakefile
+ public final void synpred27_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3028:7: ( RULE_LBRACKET )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3028:9: RULE_LBRACKET
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_synpred27_InternalCakefile6571); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred27_InternalCakefile
+
+ // $ANTLR start synpred28_InternalCakefile
+ public final void synpred28_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3038:7: ( RULE_LCURLY )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3038:9: RULE_LCURLY
+ {
+ match(input,RULE_LCURLY,FOLLOW_RULE_LCURLY_in_synpred28_InternalCakefile6605); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred28_InternalCakefile
+
+ // $ANTLR start synpred29_InternalCakefile
+ public final void synpred29_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:4: ( ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:5: ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:5: ( ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:7: ruleIdRef ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) )
+ {
+ pushFollow(FOLLOW_ruleIdRef_in_synpred29_InternalCakefile8221);
+ ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3876:16: ( ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3877:1: ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3877:1: ( ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3878:1: ( RULE_DOT | RULE_DOUBLE_COLON | RULE_QUESTION_DOT )
+ {
+ if ( (input.LA(1)>=RULE_DOT && input.LA(1)<=RULE_DOUBLE_COLON) ) {
+ input.consume();
+ state.errorRecovery=false;state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred29_InternalCakefile
+
+ // $ANTLR start synpred30_InternalCakefile
+ public final void synpred30_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:8: ( ( ruleIdRef RULE_INDEX_START ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:9: ( ruleIdRef RULE_INDEX_START )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:9: ( ruleIdRef RULE_INDEX_START )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:3967:11: ruleIdRef RULE_INDEX_START
+ {
+ pushFollow(FOLLOW_ruleIdRef_in_synpred30_InternalCakefile8384);
+ ruleIdRef();
+
+ state._fsp--;
+ if (state.failed) return ;
+ match(input,RULE_INDEX_START,FOLLOW_RULE_INDEX_START_in_synpred30_InternalCakefile8386); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred30_InternalCakefile
+
+ // $ANTLR start synpred32_InternalCakefile
+ public final void synpred32_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4274:7: ( RULE_LCURLY )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4274:9: RULE_LCURLY
+ {
+ match(input,RULE_LCURLY,FOLLOW_RULE_LCURLY_in_synpred32_InternalCakefile9139); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred32_InternalCakefile
+
+ // $ANTLR start synpred33_InternalCakefile
+ public final void synpred33_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4284:7: ( RULE_LBRACKET )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:4284:9: RULE_LBRACKET
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_synpred33_InternalCakefile9173); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred33_InternalCakefile
+
+ // $ANTLR start synpred36_InternalCakefile
+ public final void synpred36_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5137:7: ( RULE_LBRACKET )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5137:9: RULE_LBRACKET
+ {
+ match(input,RULE_LBRACKET,FOLLOW_RULE_LBRACKET_in_synpred36_InternalCakefile11097); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred36_InternalCakefile
+
+ // $ANTLR start synpred37_InternalCakefile
+ public final void synpred37_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5147:7: ( RULE_LCURLY )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5147:9: RULE_LCURLY
+ {
+ match(input,RULE_LCURLY,FOLLOW_RULE_LCURLY_in_synpred37_InternalCakefile11131); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred37_InternalCakefile
+
+ // $ANTLR start synpred38_InternalCakefile
+ public final void synpred38_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:4: ( ( RULE_LPAREN RULE_INDENT ) )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:5: ( RULE_LPAREN RULE_INDENT )
+ {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:5: ( RULE_LPAREN RULE_INDENT )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5453:7: RULE_LPAREN RULE_INDENT
+ {
+ match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_synpred38_InternalCakefile11974); if (state.failed) return ;
+ match(input,RULE_INDENT,FOLLOW_RULE_INDENT_in_synpred38_InternalCakefile11976); if (state.failed) return ;
+
+ }
+
+
+ }
+ }
+ // $ANTLR end synpred38_InternalCakefile
+
+ // $ANTLR start synpred39_InternalCakefile
+ public final void synpred39_InternalCakefile_fragment() throws RecognitionException {
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5488:8: ( RULE_LPAREN )
+ // ../csep.example.cake/src-gen/csep/example/cake/parser/antlr/internal/InternalCakefile.g:5488:10: RULE_LPAREN
+ {
+ match(input,RULE_LPAREN,FOLLOW_RULE_LPAREN_in_synpred39_InternalCakefile12055); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred39_InternalCakefile
+
+ // Delegated rules
+
+ public final boolean synpred17_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred17_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred23_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred23_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred19_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred19_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred21_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred21_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred14_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred14_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred6_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred6_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred36_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred36_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred18_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred18_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred3_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred3_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred1_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred1_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred11_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred11_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred38_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred38_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred30_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred30_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred27_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred27_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred39_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred39_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred10_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred10_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred28_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred28_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred37_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred37_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred22_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred22_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred15_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred15_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred25_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred25_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred20_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred20_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred33_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred33_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred12_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred12_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred29_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred29_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred32_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred32_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred5_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred5_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred8_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred8_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred26_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred26_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred7_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred7_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred24_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred24_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred9_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred9_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred4_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred4_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred13_InternalCakefile() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred13_InternalCakefile_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+
+
+ protected DFA19 dfa19 = new DFA19(this);
+ protected DFA29 dfa29 = new DFA29(this);
+ protected DFA54 dfa54 = new DFA54(this);
+ protected DFA62 dfa62 = new DFA62(this);
+ protected DFA95 dfa95 = new DFA95(this);
+ static final String DFA19_eotS =
+ "\12\uffff";
+ static final String DFA19_eofS =
+ "\1\5\11\uffff";
+ static final String DFA19_minS =
+ "\1\6\4\0\5\uffff";
+ static final String DFA19_maxS =
+ "\1\112\4\0\5\uffff";
+ static final String DFA19_acceptS =
+ "\5\uffff\1\5\1\1\1\2\1\3\1\4";
+ static final String DFA19_specialS =
+ "\1\uffff\1\3\1\2\1\1\1\0\5\uffff}>";
+ static final String[] DFA19_transitionS = {
+ "\1\5\1\uffff\1\5\1\uffff\2\5\5\uffff\1\1\3\uffff\1\2\1\3\1\5"+
+ "\1\4\3\uffff\1\5\1\uffff\3\5\1\uffff\11\5\13\uffff\1\5\13\uffff"+
+ "\1\5\7\uffff\1\5",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA19_eot = DFA.unpackEncodedString(DFA19_eotS);
+ static final short[] DFA19_eof = DFA.unpackEncodedString(DFA19_eofS);
+ static final char[] DFA19_min = DFA.unpackEncodedStringToUnsignedChars(DFA19_minS);
+ static final char[] DFA19_max = DFA.unpackEncodedStringToUnsignedChars(DFA19_maxS);
+ static final short[] DFA19_accept = DFA.unpackEncodedString(DFA19_acceptS);
+ static final short[] DFA19_special = DFA.unpackEncodedString(DFA19_specialS);
+ static final short[][] DFA19_transition;
+
+ static {
+ int numStates = DFA19_transitionS.length;
+ DFA19_transition = new short[numStates][];
+ for (int i=0; ithis_POST_IF_1= RULE_POST_IF ) () ( (lv_condition_3_0= ruleExpression ) ) ) | ( ( ( RULE_FOR )=>this_FOR_4= RULE_FOR ) () ( (lv_body_6_0= ruleForBody ) ) ) | ( ( ( RULE_WHILE )=>this_WHILE_7= RULE_WHILE ) () ( (lv_body_9_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_10= RULE_WHEN ) ( (lv_when_11_0= ruleExpression ) ) )? ) | ( ( ( RULE_UNTIL )=>this_UNTIL_12= RULE_UNTIL ) () ( (lv_body_14_0= ruleExpression ) ) ( ( ( RULE_WHEN )=>this_WHEN_15= RULE_WHEN ) ( (lv_when_16_0= ruleExpression ) ) )? ) )?";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA19_4 = input.LA(1);
+
+
+ int index19_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred7_InternalCakefile()) ) {s = 9;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index19_4);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA19_3 = input.LA(1);
+
+
+ int index19_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred5_InternalCakefile()) ) {s = 8;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index19_3);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA19_2 = input.LA(1);
+
+
+ int index19_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred4_InternalCakefile()) ) {s = 7;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index19_2);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA19_1 = input.LA(1);
+
+
+ int index19_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred3_InternalCakefile()) ) {s = 6;}
+
+ else if ( (true) ) {s = 5;}
+
+
+ input.seek(index19_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 19, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA29_eotS =
+ "\35\uffff";
+ static final String DFA29_eofS =
+ "\35\uffff";
+ static final String DFA29_minS =
+ "\1\7\5\0\27\uffff";
+ static final String DFA29_maxS =
+ "\1\111\5\0\27\uffff";
+ static final String DFA29_acceptS =
+ "\6\uffff\1\2\25\uffff\1\1";
+ static final String DFA29_specialS =
+ "\1\uffff\1\0\1\1\1\2\1\3\1\4\27\uffff}>";
+ static final String[] DFA29_transitionS = {
+ "\1\6\1\uffff\1\6\5\uffff\1\6\5\uffff\2\6\1\uffff\1\6\4\uffff"+
+ "\1\5\12\uffff\2\6\1\uffff\3\6\1\uffff\1\6\1\uffff\1\2\5\uffff"+
+ "\1\3\2\6\2\uffff\1\6\2\uffff\1\6\1\1\1\4\2\uffff\6\6",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA29_eot = DFA.unpackEncodedString(DFA29_eotS);
+ static final short[] DFA29_eof = DFA.unpackEncodedString(DFA29_eofS);
+ static final char[] DFA29_min = DFA.unpackEncodedStringToUnsignedChars(DFA29_minS);
+ static final char[] DFA29_max = DFA.unpackEncodedStringToUnsignedChars(DFA29_maxS);
+ static final short[] DFA29_accept = DFA.unpackEncodedString(DFA29_acceptS);
+ static final short[] DFA29_special = DFA.unpackEncodedString(DFA29_specialS);
+ static final short[][] DFA29_transition;
+
+ static {
+ int numStates = DFA29_transitionS.length;
+ DFA29_transition = new short[numStates][];
+ for (int i=0; i ( ( (lv_left_0_0= ruleAssignable ) ) ( ( (lv_operator_1_1= RULE_EQUAL | lv_operator_1_2= RULE_COMPOUND_ASSIGN ) ) ) ) ) ( (lv_right_2_0= ruleAssigned ) ) ) | this_LogicOp_3= ruleLogicOp )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA29_1 = input.LA(1);
+
+
+ int index29_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCakefile()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index29_1);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA29_2 = input.LA(1);
+
+
+ int index29_2 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCakefile()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index29_2);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA29_3 = input.LA(1);
+
+
+ int index29_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCakefile()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index29_3);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA29_4 = input.LA(1);
+
+
+ int index29_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCakefile()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index29_4);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA29_5 = input.LA(1);
+
+
+ int index29_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred17_InternalCakefile()) ) {s = 28;}
+
+ else if ( (true) ) {s = 6;}
+
+
+ input.seek(index29_5);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 29, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA54_eotS =
+ "\40\uffff";
+ static final String DFA54_eofS =
+ "\40\uffff";
+ static final String DFA54_minS =
+ "\1\7\2\uffff\33\0\2\uffff";
+ static final String DFA54_maxS =
+ "\1\111\2\uffff\33\0\2\uffff";
+ static final String DFA54_acceptS =
+ "\1\uffff\2\1\33\uffff\1\2\1\3";
+ static final String DFA54_specialS =
+ "\1\0\2\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
+ "\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31"+
+ "\1\32\1\33\2\uffff}>";
+ static final String[] DFA54_transitionS = {
+ "\1\25\1\uffff\1\26\5\uffff\1\21\5\uffff\1\30\1\31\1\uffff\1"+
+ "\32\4\uffff\1\7\1\1\1\2\10\uffff\1\11\1\12\1\uffff\1\10\1\13"+
+ "\1\14\1\uffff\1\15\1\uffff\1\4\5\uffff\1\5\1\33\1\34\2\uffff"+
+ "\1\35\2\uffff\1\16\1\3\1\6\2\uffff\1\27\1\20\1\22\1\23\1\24"+
+ "\1\17",
+ "",
+ "",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "\1\uffff",
+ "",
+ ""
+ };
+
+ static final short[] DFA54_eot = DFA.unpackEncodedString(DFA54_eotS);
+ static final short[] DFA54_eof = DFA.unpackEncodedString(DFA54_eofS);
+ static final char[] DFA54_min = DFA.unpackEncodedStringToUnsignedChars(DFA54_minS);
+ static final char[] DFA54_max = DFA.unpackEncodedStringToUnsignedChars(DFA54_maxS);
+ static final short[] DFA54_accept = DFA.unpackEncodedString(DFA54_acceptS);
+ static final short[] DFA54_special = DFA.unpackEncodedString(DFA54_specialS);
+ static final short[][] DFA54_transition;
+
+ static {
+ int numStates = DFA54_transitionS.length;
+ DFA54_transition = new short[numStates][];
+ for (int i=0; i ( (lv_dots_0_1= RULE_DOT_DOT | lv_dots_0_2= RULE_ELLIPSIS ) ) ) ( (lv_end_1_0= ruleExpression ) ) ) | ( ( ( ( ( ( ruleExpression ) ) ( ( ( RULE_DOT_DOT | RULE_ELLIPSIS ) ) ) ) )=> ( ( (lv_start_2_0= ruleExpression ) ) ( ( (lv_dots_3_1= RULE_DOT_DOT | lv_dots_3_2= RULE_ELLIPSIS ) ) ) ) ) ( (lv_end_4_0= ruleExpression ) )? ) | ( (lv_exp_5_0= ruleExpression ) ) )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA54_0 = input.LA(1);
+
+
+ int index54_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA54_0==RULE_DOT_DOT) && (synpred24_InternalCakefile())) {s = 1;}
+
+ else if ( (LA54_0==RULE_ELLIPSIS) && (synpred24_InternalCakefile())) {s = 2;}
+
+ else if ( (LA54_0==RULE_IDENTIFIER) ) {s = 3;}
+
+ else if ( (LA54_0==RULE_AT_SIGIL) ) {s = 4;}
+
+ else if ( (LA54_0==RULE_THIS) ) {s = 5;}
+
+ else if ( (LA54_0==RULE_LCURLY) ) {s = 6;}
+
+ else if ( (LA54_0==RULE_LBRACKET) ) {s = 7;}
+
+ else if ( (LA54_0==RULE_UNARY) ) {s = 8;}
+
+ else if ( (LA54_0==RULE_PLUS) ) {s = 9;}
+
+ else if ( (LA54_0==RULE_MINUS) ) {s = 10;}
+
+ else if ( (LA54_0==RULE_PLUS_PLUS) ) {s = 11;}
+
+ else if ( (LA54_0==RULE_MINUS_MINUS) ) {s = 12;}
+
+ else if ( (LA54_0==RULE_SUPER) ) {s = 13;}
+
+ else if ( (LA54_0==RULE_IF) ) {s = 14;}
+
+ else if ( (LA54_0==RULE_LPAREN) ) {s = 15;}
+
+ else if ( (LA54_0==RULE_NUMBER) ) {s = 16;}
+
+ else if ( (LA54_0==RULE_STRING) ) {s = 17;}
+
+ else if ( (LA54_0==RULE_BOOL) ) {s = 18;}
+
+ else if ( (LA54_0==RULE_JS) ) {s = 19;}
+
+ else if ( (LA54_0==RULE_REGEX) ) {s = 20;}
+
+ else if ( (LA54_0==RULE_PARAM_START) ) {s = 21;}
+
+ else if ( (LA54_0==RULE_FUNC_ARROW) ) {s = 22;}
+
+ else if ( (LA54_0==RULE_BOUND_FUNC_ARROW) ) {s = 23;}
+
+ else if ( (LA54_0==RULE_FOR) ) {s = 24;}
+
+ else if ( (LA54_0==RULE_WHILE) ) {s = 25;}
+
+ else if ( (LA54_0==RULE_UNTIL) ) {s = 26;}
+
+ else if ( (LA54_0==RULE_LOOP) ) {s = 27;}
+
+ else if ( (LA54_0==RULE_TRY) ) {s = 28;}
+
+ else if ( (LA54_0==RULE_SWITCH) ) {s = 29;}
+
+
+ input.seek(index54_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA54_3 = input.LA(1);
+
+
+ int index54_3 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_3);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA54_4 = input.LA(1);
+
+
+ int index54_4 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_4);
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA54_5 = input.LA(1);
+
+
+ int index54_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_5);
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA54_6 = input.LA(1);
+
+
+ int index54_6 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_6);
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA54_7 = input.LA(1);
+
+
+ int index54_7 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_7);
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA54_8 = input.LA(1);
+
+
+ int index54_8 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_8);
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA54_9 = input.LA(1);
+
+
+ int index54_9 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_9);
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA54_10 = input.LA(1);
+
+
+ int index54_10 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_10);
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA54_11 = input.LA(1);
+
+
+ int index54_11 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_11);
+ if ( s>=0 ) return s;
+ break;
+ case 10 :
+ int LA54_12 = input.LA(1);
+
+
+ int index54_12 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_12);
+ if ( s>=0 ) return s;
+ break;
+ case 11 :
+ int LA54_13 = input.LA(1);
+
+
+ int index54_13 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_13);
+ if ( s>=0 ) return s;
+ break;
+ case 12 :
+ int LA54_14 = input.LA(1);
+
+
+ int index54_14 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_14);
+ if ( s>=0 ) return s;
+ break;
+ case 13 :
+ int LA54_15 = input.LA(1);
+
+
+ int index54_15 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_15);
+ if ( s>=0 ) return s;
+ break;
+ case 14 :
+ int LA54_16 = input.LA(1);
+
+
+ int index54_16 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_16);
+ if ( s>=0 ) return s;
+ break;
+ case 15 :
+ int LA54_17 = input.LA(1);
+
+
+ int index54_17 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_17);
+ if ( s>=0 ) return s;
+ break;
+ case 16 :
+ int LA54_18 = input.LA(1);
+
+
+ int index54_18 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_18);
+ if ( s>=0 ) return s;
+ break;
+ case 17 :
+ int LA54_19 = input.LA(1);
+
+
+ int index54_19 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_19);
+ if ( s>=0 ) return s;
+ break;
+ case 18 :
+ int LA54_20 = input.LA(1);
+
+
+ int index54_20 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_20);
+ if ( s>=0 ) return s;
+ break;
+ case 19 :
+ int LA54_21 = input.LA(1);
+
+
+ int index54_21 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_21);
+ if ( s>=0 ) return s;
+ break;
+ case 20 :
+ int LA54_22 = input.LA(1);
+
+
+ int index54_22 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_22);
+ if ( s>=0 ) return s;
+ break;
+ case 21 :
+ int LA54_23 = input.LA(1);
+
+
+ int index54_23 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_23);
+ if ( s>=0 ) return s;
+ break;
+ case 22 :
+ int LA54_24 = input.LA(1);
+
+
+ int index54_24 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_24);
+ if ( s>=0 ) return s;
+ break;
+ case 23 :
+ int LA54_25 = input.LA(1);
+
+
+ int index54_25 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_25);
+ if ( s>=0 ) return s;
+ break;
+ case 24 :
+ int LA54_26 = input.LA(1);
+
+
+ int index54_26 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_26);
+ if ( s>=0 ) return s;
+ break;
+ case 25 :
+ int LA54_27 = input.LA(1);
+
+
+ int index54_27 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_27);
+ if ( s>=0 ) return s;
+ break;
+ case 26 :
+ int LA54_28 = input.LA(1);
+
+
+ int index54_28 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_28);
+ if ( s>=0 ) return s;
+ break;
+ case 27 :
+ int LA54_29 = input.LA(1);
+
+
+ int index54_29 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred25_InternalCakefile()) ) {s = 30;}
+
+ else if ( (true) ) {s = 31;}
+
+
+ input.seek(index54_29);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 54, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA62_eotS =
+ "\30\uffff";
+ static final String DFA62_eofS =
+ "\30\uffff";
+ static final String DFA62_minS =
+ "\1\7\7\uffff\1\0\17\uffff";
+ static final String DFA62_maxS =
+ "\1\111\7\uffff\1\0\17\uffff";
+ static final String DFA62_acceptS =
+ "\1\uffff\1\1\1\2\1\3\5\uffff\1\6\1\7\2\uffff\1\10\1\11\1\12\1\13"+
+ "\1\14\1\15\1\16\1\17\1\20\1\4\1\5";
+ static final String DFA62_specialS =
+ "\1\0\7\uffff\1\1\17\uffff}>";
+ static final String[] DFA62_transitionS = {
+ "\1\12\1\uffff\1\12\5\uffff\1\3\5\uffff\1\17\1\20\1\uffff\1\21"+
+ "\4\uffff\1\10\23\uffff\1\15\5\uffff\1\16\1\22\1\23\2\uffff\1"+
+ "\24\2\uffff\1\1\1\25\1\11\2\uffff\1\12\4\3\1\2",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\uffff",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA62_eot = DFA.unpackEncodedString(DFA62_eotS);
+ static final short[] DFA62_eof = DFA.unpackEncodedString(DFA62_eofS);
+ static final char[] DFA62_min = DFA.unpackEncodedStringToUnsignedChars(DFA62_minS);
+ static final char[] DFA62_max = DFA.unpackEncodedStringToUnsignedChars(DFA62_maxS);
+ static final short[] DFA62_accept = DFA.unpackEncodedString(DFA62_acceptS);
+ static final short[] DFA62_special = DFA.unpackEncodedString(DFA62_specialS);
+ static final short[][] DFA62_transition;
+
+ static {
+ int numStates = DFA62_transitionS.length;
+ DFA62_transition = new short[numStates][];
+ for (int i=0; ithis_Range_3= ruleRange ) | ( ( RULE_LBRACKET )=>this_Array_4= ruleArray ) | ( ( RULE_LCURLY )=>this_Dictionary_5= ruleDictionary ) | this_Lambda_6= ruleLambda | this_ThisProperty_7= ruleThisProperty | ( () this_THIS_9= RULE_THIS ) | ( () (this_FOR_11= RULE_FOR ( (lv_loop_12_0= ruleForBody ) ) ( (lv_body_13_0= ruleBlock ) ) ) ) | ( () (this_WHILE_15= RULE_WHILE ( (lv_loop_16_0= ruleExpression ) ) (this_WHEN_17= RULE_WHEN ( (lv_when_18_0= ruleExpression ) ) )? ( (lv_body_19_0= ruleBlock ) ) ) ) | ( () (this_UNTIL_21= RULE_UNTIL ( (lv_loop_22_0= ruleExpression ) ) (this_WHEN_23= RULE_WHEN ( (lv_when_24_0= ruleExpression ) ) )? ( (lv_body_25_0= ruleBlock ) ) ) ) | ( () (this_LOOP_27= RULE_LOOP ( (lv_body_28_0= ruleBlock ) ) ) ) | ( () (this_TRY_30= RULE_TRY ( (lv_body_31_0= ruleBlock ) ) ( (this_CATCH_32= RULE_CATCH ( (lv_exception_33_0= ruleId ) ) ( (lv_catchBlock_34_0= ruleBlock ) ) (this_FINALLY_35= RULE_FINALLY ( (lv_finallyBlock_36_0= ruleBlock ) ) )? ) | (this_FINALLY_37= RULE_FINALLY ( (lv_finallyBlock_38_0= ruleBlock ) ) ) )? ) ) | ( () (this_SWITCH_40= RULE_SWITCH ( (lv_exp_41_0= ruleExpression ) )? this_INDENT_42= RULE_INDENT ( (lv_cases_43_0= ruleCase ) )* (this_ELSE_44= RULE_ELSE ( (lv_elseBlock_45_0= ruleBlock ) ) )? this_OUTDENT_46= RULE_OUTDENT ) ) | this_IdRef_47= ruleIdRef )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA62_0 = input.LA(1);
+
+
+ int index62_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA62_0==RULE_IF) ) {s = 1;}
+
+ else if ( (LA62_0==RULE_LPAREN) ) {s = 2;}
+
+ else if ( (LA62_0==RULE_STRING||(LA62_0>=RULE_NUMBER && LA62_0<=RULE_REGEX)) ) {s = 3;}
+
+ else if ( (LA62_0==RULE_LBRACKET) ) {s = 8;}
+
+ else if ( (LA62_0==RULE_LCURLY) && (synpred28_InternalCakefile())) {s = 9;}
+
+ else if ( (LA62_0==RULE_PARAM_START||LA62_0==RULE_FUNC_ARROW||LA62_0==RULE_BOUND_FUNC_ARROW) ) {s = 10;}
+
+ else if ( (LA62_0==RULE_AT_SIGIL) ) {s = 13;}
+
+ else if ( (LA62_0==RULE_THIS) ) {s = 14;}
+
+ else if ( (LA62_0==RULE_FOR) ) {s = 15;}
+
+ else if ( (LA62_0==RULE_WHILE) ) {s = 16;}
+
+ else if ( (LA62_0==RULE_UNTIL) ) {s = 17;}
+
+ else if ( (LA62_0==RULE_LOOP) ) {s = 18;}
+
+ else if ( (LA62_0==RULE_TRY) ) {s = 19;}
+
+ else if ( (LA62_0==RULE_SWITCH) ) {s = 20;}
+
+ else if ( (LA62_0==RULE_IDENTIFIER) ) {s = 21;}
+
+
+ input.seek(index62_0);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA62_8 = input.LA(1);
+
+
+ int index62_8 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (synpred26_InternalCakefile()) ) {s = 22;}
+
+ else if ( (synpred27_InternalCakefile()) ) {s = 23;}
+
+
+ input.seek(index62_8);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 62, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+ static final String DFA95_eotS =
+ "\43\uffff";
+ static final String DFA95_eofS =
+ "\43\uffff";
+ static final String DFA95_minS =
+ "\1\111\1\7\41\uffff";
+ static final String DFA95_maxS =
+ "\2\111\41\uffff";
+ static final String DFA95_acceptS =
+ "\2\uffff\40\2\1\1";
+ static final String DFA95_specialS =
+ "\1\uffff\1\0\41\uffff}>";
+ static final String[] DFA95_transitionS = {
+ "\1\1",
+ "\1\31\1\uffff\1\32\2\uffff\1\7\1\5\1\uffff\1\25\1\2\1\uffff"+
+ "\1\3\1\6\1\uffff\1\34\1\35\1\uffff\1\36\4\uffff\1\13\4\uffff"+
+ "\1\42\5\uffff\1\15\1\16\1\uffff\1\14\1\17\1\20\1\uffff\1\21"+
+ "\1\uffff\1\10\5\uffff\1\11\1\37\1\40\2\uffff\1\41\2\uffff\1"+
+ "\22\1\4\1\12\2\uffff\1\33\1\24\1\26\1\27\1\30\1\23",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA95_eot = DFA.unpackEncodedString(DFA95_eotS);
+ static final short[] DFA95_eof = DFA.unpackEncodedString(DFA95_eofS);
+ static final char[] DFA95_min = DFA.unpackEncodedStringToUnsignedChars(DFA95_minS);
+ static final char[] DFA95_max = DFA.unpackEncodedStringToUnsignedChars(DFA95_maxS);
+ static final short[] DFA95_accept = DFA.unpackEncodedString(DFA95_acceptS);
+ static final short[] DFA95_special = DFA.unpackEncodedString(DFA95_specialS);
+ static final short[][] DFA95_transition;
+
+ static {
+ int numStates = DFA95_transitionS.length;
+ DFA95_transition = new short[numStates][];
+ for (int i=0; i (this_LPAREN_0= RULE_LPAREN this_INDENT_1= RULE_INDENT ) ) ( (lv_content_2_0= ruleBody ) ) this_OUTDENT_3= RULE_OUTDENT this_RPAREN_4= RULE_RPAREN ) | ( ( ( RULE_LPAREN )=>this_LPAREN_5= RULE_LPAREN ) ( (lv_content_6_0= ruleBody ) ) this_RPAREN_7= RULE_RPAREN ) )";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ TokenStream input = (TokenStream)_input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA95_1 = input.LA(1);
+
+
+ int index95_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA95_1==RULE_RETURN) && (synpred39_InternalCakefile())) {s = 2;}
+
+ else if ( (LA95_1==RULE_THROW) && (synpred39_InternalCakefile())) {s = 3;}
+
+ else if ( (LA95_1==RULE_IDENTIFIER) && (synpred39_InternalCakefile())) {s = 4;}
+
+ else if ( (LA95_1==RULE_HERECOMMENT) && (synpred39_InternalCakefile())) {s = 5;}
+
+ else if ( (LA95_1==RULE_CLASS) && (synpred39_InternalCakefile())) {s = 6;}
+
+ else if ( (LA95_1==RULE_STATEMENT) && (synpred39_InternalCakefile())) {s = 7;}
+
+ else if ( (LA95_1==RULE_AT_SIGIL) && (synpred39_InternalCakefile())) {s = 8;}
+
+ else if ( (LA95_1==RULE_THIS) && (synpred39_InternalCakefile())) {s = 9;}
+
+ else if ( (LA95_1==RULE_LCURLY) && (synpred39_InternalCakefile())) {s = 10;}
+
+ else if ( (LA95_1==RULE_LBRACKET) && (synpred39_InternalCakefile())) {s = 11;}
+
+ else if ( (LA95_1==RULE_UNARY) && (synpred39_InternalCakefile())) {s = 12;}
+
+ else if ( (LA95_1==RULE_PLUS) && (synpred39_InternalCakefile())) {s = 13;}
+
+ else if ( (LA95_1==RULE_MINUS) && (synpred39_InternalCakefile())) {s = 14;}
+
+ else if ( (LA95_1==RULE_PLUS_PLUS) && (synpred39_InternalCakefile())) {s = 15;}
+
+ else if ( (LA95_1==RULE_MINUS_MINUS) && (synpred39_InternalCakefile())) {s = 16;}
+
+ else if ( (LA95_1==RULE_SUPER) && (synpred39_InternalCakefile())) {s = 17;}
+
+ else if ( (LA95_1==RULE_IF) && (synpred39_InternalCakefile())) {s = 18;}
+
+ else if ( (LA95_1==RULE_LPAREN) && (synpred39_InternalCakefile())) {s = 19;}
+
+ else if ( (LA95_1==RULE_NUMBER) && (synpred39_InternalCakefile())) {s = 20;}
+
+ else if ( (LA95_1==RULE_STRING) && (synpred39_InternalCakefile())) {s = 21;}
+
+ else if ( (LA95_1==RULE_BOOL) && (synpred39_InternalCakefile())) {s = 22;}
+
+ else if ( (LA95_1==RULE_JS) && (synpred39_InternalCakefile())) {s = 23;}
+
+ else if ( (LA95_1==RULE_REGEX) && (synpred39_InternalCakefile())) {s = 24;}
+
+ else if ( (LA95_1==RULE_PARAM_START) && (synpred39_InternalCakefile())) {s = 25;}
+
+ else if ( (LA95_1==RULE_FUNC_ARROW) && (synpred39_InternalCakefile())) {s = 26;}
+
+ else if ( (LA95_1==RULE_BOUND_FUNC_ARROW) && (synpred39_InternalCakefile())) {s = 27;}
+
+ else if ( (LA95_1==RULE_FOR) && (synpred39_InternalCakefile())) {s = 28;}
+
+ else if ( (LA95_1==RULE_WHILE) && (synpred39_InternalCakefile())) {s = 29;}
+
+ else if ( (LA95_1==RULE_UNTIL) && (synpred39_InternalCakefile())) {s = 30;}
+
+ else if ( (LA95_1==RULE_LOOP) && (synpred39_InternalCakefile())) {s = 31;}
+
+ else if ( (LA95_1==RULE_TRY) && (synpred39_InternalCakefile())) {s = 32;}
+
+ else if ( (LA95_1==RULE_SWITCH) && (synpred39_InternalCakefile())) {s = 33;}
+
+ else if ( (LA95_1==RULE_INDENT) && (synpred38_InternalCakefile())) {s = 34;}
+
+
+ input.seek(index95_1);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 95, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+ public static final BitSet FOLLOW_ruleCakefile_in_entryRuleCakefile75 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCakefile85 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleTaskDeclaration_in_ruleCakefile130 = new BitSet(new long[]{0x0000000000000012L});
+ public static final BitSet FOLLOW_ruleTaskDeclaration_in_entryRuleTaskDeclaration166 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleTaskDeclaration176 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TASK_in_ruleTaskDeclaration212 = new BitSet(new long[]{0x0000000000000020L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_ruleTaskDeclaration222 = new BitSet(new long[]{0x0000000000008000L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_ruleTaskDeclaration242 = new BitSet(new long[]{0x0000000000000040L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleTaskDeclaration253 = new BitSet(new long[]{0x0000000000008000L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_ruleTaskDeclaration273 = new BitSet(new long[]{0x0000000000000040L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleTaskDeclaration284 = new BitSet(new long[]{0x0000000000000280L});
+ public static final BitSet FOLLOW_RULE_PARAM_START_in_ruleTaskDeclaration295 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleId_in_ruleTaskDeclaration315 = new BitSet(new long[]{0x0000000000000100L});
+ public static final BitSet FOLLOW_RULE_PARAM_END_in_ruleTaskDeclaration326 = new BitSet(new long[]{0x0000000000000200L});
+ public static final BitSet FOLLOW_RULE_FUNC_ARROW_in_ruleTaskDeclaration338 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleTaskDeclaration358 = new BitSet(new long[]{0x0000000000000400L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_ruleTaskDeclaration369 = new BitSet(new long[]{0x0000000000000800L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleTaskDeclaration379 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBody_in_entryRuleBody416 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleBody426 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLine_in_ruleBody472 = new BitSet(new long[]{0x0000000000000802L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleBody484 = new BitSet(new long[]{0x9382BB00216DBA82L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleLine_in_ruleBody504 = new BitSet(new long[]{0x0000000000000802L});
+ public static final BitSet FOLLOW_ruleLine_in_entryRuleLine543 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLine553 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStmt_in_ruleLine600 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleLine627 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStmt_in_entryRuleStmt662 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleStmt672 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleReturnStmt_in_ruleStmt719 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThrowStmt_in_ruleStmt746 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRequireStmt_in_ruleStmt794 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleComment_in_ruleStmt822 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleClassDeclaration_in_ruleStmt849 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_STATEMENT_in_ruleStmt871 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleComment_in_entryRuleComment912 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleComment922 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_HERECOMMENT_in_ruleComment963 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRequireStmt_in_entryRuleRequireStmt1003 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRequireStmt1013 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleRequireStmt1081 = new BitSet(new long[]{0x0000000000004000L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_ruleRequireStmt1092 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
+ public static final BitSet FOLLOW_86_in_ruleRequireStmt1103 = new BitSet(new long[]{0x0000000000000020L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_ruleRequireStmt1116 = new BitSet(new long[]{0x0000000000008000L});
+ public static final BitSet FOLLOW_RULE_STRING_in_ruleRequireStmt1132 = new BitSet(new long[]{0x0000000000000400L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_ruleRequireStmt1148 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleReturnStmt_in_entryRuleReturnStmt1183 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleReturnStmt1193 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RETURN_in_ruleReturnStmt1238 = new BitSet(new long[]{0x9382BB00216FB282L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleReturnStmt1258 = new BitSet(new long[]{0x0000000000020002L});
+ public static final BitSet FOLLOW_RULE_POST_IF_in_ruleReturnStmt1271 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleReturnStmt1291 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThrowStmt_in_entryRuleThrowStmt1329 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleThrowStmt1339 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_THROW_in_ruleThrowStmt1375 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleThrowStmt1395 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_entryRuleSuperClass1431 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleSuperClass1441 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_ruleSuperClass1488 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_ruleSuperClass1515 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleClassDeclaration_in_entryRuleClassDeclaration1550 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleClassDeclaration1560 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CLASS_in_ruleClassDeclaration1605 = new BitSet(new long[]{0x0082000400100002L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleClassDeclaration1626 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_ruleClassDeclaration1644 = new BitSet(new long[]{0x0082000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_ruleClassDeclaration1664 = new BitSet(new long[]{0x0000000400000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleClassDeclaration1685 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleClassDeclaration1717 = new BitSet(new long[]{0x0000000400100000L});
+ public static final BitSet FOLLOW_ruleProperty_in_ruleClassDeclaration1736 = new BitSet(new long[]{0x0000000400100000L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_ruleClassDeclaration1751 = new BitSet(new long[]{0x0082000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_ruleClassDeclaration1771 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleClassDeclaration1794 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignedClassDeclaration_in_entryRuleAssignedClassDeclaration1833 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignedClassDeclaration1843 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_CLASS_in_ruleAssignedClassDeclaration1888 = new BitSet(new long[]{0x0082000000100002L,0x0000000000000001L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_ruleAssignedClassDeclaration1900 = new BitSet(new long[]{0x0082000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_ruleAssignedClassDeclaration1920 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleAssignedClassDeclaration1941 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleAssignedClassDeclaration1972 = new BitSet(new long[]{0x0000000400100000L});
+ public static final BitSet FOLLOW_ruleProperty_in_ruleAssignedClassDeclaration1991 = new BitSet(new long[]{0x0000000400100000L});
+ public static final BitSet FOLLOW_RULE_EXTENDS_in_ruleAssignedClassDeclaration2006 = new BitSet(new long[]{0x0082000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleSuperClass_in_ruleAssignedClassDeclaration2026 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleAssignedClassDeclaration2049 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_entryRuleExpression2088 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleExpression2098 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePostfix_in_ruleExpression2144 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePostfix_in_entryRulePostfix2178 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRulePostfix2188 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignment_in_rulePostfix2235 = new BitSet(new long[]{0x0000000001620002L});
+ public static final BitSet FOLLOW_RULE_POST_IF_in_rulePostfix2253 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2283 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOR_in_rulePostfix2308 = new BitSet(new long[]{0x0000000002000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleForBody_in_rulePostfix2338 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHILE_in_rulePostfix2363 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2393 = new BitSet(new long[]{0x0000000000800002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rulePostfix2411 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2432 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNTIL_in_rulePostfix2459 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2489 = new BitSet(new long[]{0x0000000000800002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rulePostfix2507 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePostfix2528 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForBody_in_entryRuleForBody2569 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleForBody2579 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_OWN_in_ruleForBody2616 = new BitSet(new long[]{0x0000000002000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleForValue_in_ruleForBody2638 = new BitSet(new long[]{0x000000000C000040L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleForBody2650 = new BitSet(new long[]{0x0000000002000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleForValue_in_ruleForBody2670 = new BitSet(new long[]{0x000000000C000040L});
+ public static final BitSet FOLLOW_ruleForSource_in_ruleForBody2693 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForValue_in_entryRuleForValue2729 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleForValue2739 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleForValue2785 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleForSource_in_entryRuleForSource2819 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleForSource2829 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOROF_in_ruleForSource2882 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2903 = new BitSet(new long[]{0x0000000000800002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_ruleForSource2921 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2942 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FORIN_in_ruleForSource2969 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource2990 = new BitSet(new long[]{0x0000000010800002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_ruleForSource3009 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource3030 = new BitSet(new long[]{0x0000000010000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_ruleForSource3048 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource3069 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_ruleForSource3096 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource3117 = new BitSet(new long[]{0x0000000000800002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_ruleForSource3135 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleForSource3156 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRange_in_entryRuleRange3199 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRange3209 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_ruleRange3275 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleRange3295 = new BitSet(new long[]{0x00000000C0000000L});
+ public static final BitSet FOLLOW_RULE_DOT_DOT_in_ruleRange3307 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleRange3323 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleRange3346 = new BitSet(new long[]{0x0000000100000000L});
+ public static final BitSet FOLLOW_RULE_RBRACKET_in_ruleRange3357 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignment_in_entryRuleAssignment3392 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignment3402 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_ruleAssignment3490 = new BitSet(new long[]{0x0000000200004000L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_ruleAssignment3509 = new BitSet(new long[]{0x9382BB04216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_RULE_COMPOUND_ASSIGN_in_ruleAssignment3529 = new BitSet(new long[]{0x9382BB04216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleAssigned_in_ruleAssignment3560 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLogicOp_in_ruleAssignment3589 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssigned_in_entryRuleAssigned3624 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssigned3634 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleAssigned3681 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleAssigned3698 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleAssigned3719 = new BitSet(new long[]{0x0000000800000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleAssigned3729 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignedClassDeclaration_in_ruleAssigned3757 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLogicOp_in_entryRuleLogicOp3792 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLogicOp3802 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCompareOp_in_ruleLogicOp3849 = new BitSet(new long[]{0x0000001000000002L});
+ public static final BitSet FOLLOW_RULE_LOGIC_in_ruleLogicOp3895 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleCompareOp_in_ruleLogicOp3923 = new BitSet(new long[]{0x0000001000000002L});
+ public static final BitSet FOLLOW_ruleCompareOp_in_entryRuleCompareOp3961 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCompareOp3971 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRelationOp_in_ruleCompareOp4018 = new BitSet(new long[]{0x0000002000000002L});
+ public static final BitSet FOLLOW_RULE_COMPARE_in_ruleCompareOp4064 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleRelationOp_in_ruleCompareOp4092 = new BitSet(new long[]{0x0000002000000002L});
+ public static final BitSet FOLLOW_ruleRelationOp_in_entryRuleRelationOp4130 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRelationOp4140 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleShiftOp_in_ruleRelationOp4187 = new BitSet(new long[]{0x0000004000000002L});
+ public static final BitSet FOLLOW_RULE_RELATION_in_ruleRelationOp4233 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleShiftOp_in_ruleRelationOp4261 = new BitSet(new long[]{0x0000004000000002L});
+ public static final BitSet FOLLOW_ruleShiftOp_in_entryRuleShiftOp4299 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleShiftOp4309 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAdditiveOp_in_ruleShiftOp4356 = new BitSet(new long[]{0x0000008000000002L});
+ public static final BitSet FOLLOW_RULE_SHIFT_in_ruleShiftOp4402 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleAdditiveOp_in_ruleShiftOp4430 = new BitSet(new long[]{0x0000008000000002L});
+ public static final BitSet FOLLOW_ruleAdditiveOp_in_entryRuleAdditiveOp4468 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAdditiveOp4478 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleMathOp_in_ruleAdditiveOp4525 = new BitSet(new long[]{0x0000030000000002L});
+ public static final BitSet FOLLOW_RULE_PLUS_in_ruleAdditiveOp4588 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_RULE_MINUS_in_ruleAdditiveOp4608 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleMathOp_in_ruleAdditiveOp4639 = new BitSet(new long[]{0x0000030000000002L});
+ public static final BitSet FOLLOW_ruleMathOp_in_entryRuleMathOp4677 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleMathOp4687 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleUnaryOp_in_ruleMathOp4734 = new BitSet(new long[]{0x0000040000000002L});
+ public static final BitSet FOLLOW_RULE_MATH_in_ruleMathOp4780 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleUnaryOp_in_ruleMathOp4808 = new BitSet(new long[]{0x0000040000000002L});
+ public static final BitSet FOLLOW_ruleUnaryOp_in_entryRuleUnaryOp4846 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleUnaryOp4856 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNARY_in_ruleUnaryOp4894 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_RULE_PLUS_in_ruleUnaryOp4910 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_RULE_MINUS_in_ruleUnaryOp4926 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleUnaryOp4948 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PLUS_PLUS_in_ruleUnaryOp4967 = new BitSet(new long[]{0x0082000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_RULE_MINUS_MINUS_in_ruleUnaryOp4983 = new BitSet(new long[]{0x0082000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleVariable_in_ruleUnaryOp5005 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleApplication_in_ruleUnaryOp5034 = new BitSet(new long[]{0x0000400000000002L});
+ public static final BitSet FOLLOW_RULE_QUESTION_in_ruleUnaryOp5045 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleApplication_in_entryRuleApplication5083 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleApplication5093 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_SUPER_in_ruleApplication5140 = new BitSet(new long[]{0x0000000000000022L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_ruleApplication5151 = new BitSet(new long[]{0x9382BB04216DB680L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleArgList_in_ruleApplication5171 = new BitSet(new long[]{0x0000000000000400L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_ruleApplication5182 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePrimaryExpression_in_ruleApplication5213 = new BitSet(new long[]{0x003D000000000022L});
+ public static final BitSet FOLLOW_ruleFeatureCall_in_ruleApplication5234 = new BitSet(new long[]{0x003D000000000022L});
+ public static final BitSet FOLLOW_ruleFeatureCall_in_entryRuleFeatureCall5272 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleFeatureCall5282 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleFunctionCall_in_ruleFeatureCall5329 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePropertyAccess_in_ruleFeatureCall5356 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleFunctionCall_in_entryRuleFunctionCall5391 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleFunctionCall5401 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FUNC_EXIST_in_ruleFunctionCall5447 = new BitSet(new long[]{0x0000000000000020L});
+ public static final BitSet FOLLOW_RULE_CALL_START_in_ruleFunctionCall5459 = new BitSet(new long[]{0x9382BB04216DB680L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleArgList_in_ruleFunctionCall5479 = new BitSet(new long[]{0x0000000000000400L});
+ public static final BitSet FOLLOW_RULE_CALL_END_in_ruleFunctionCall5490 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePropertyAccess_in_entryRulePropertyAccess5525 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRulePropertyAccess5535 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNamedPropertyAccess_in_rulePropertyAccess5582 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndexedPropertyAccess_in_rulePropertyAccess5609 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThisProperty_in_entryRuleThisProperty5644 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleThisProperty5654 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_AT_SIGIL_in_ruleThisProperty5690 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleId_in_ruleThisProperty5711 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNamedPropertyAccess_in_entryRuleNamedPropertyAccess5746 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleNamedPropertyAccess5756 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_in_ruleNamedPropertyAccess5801 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_RULE_QUESTION_DOT_in_ruleNamedPropertyAccess5821 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleId_in_ruleNamedPropertyAccess5850 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOUBLE_COLON_in_ruleNamedPropertyAccess5875 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleId_in_ruleNamedPropertyAccess5901 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndexedPropertyAccess_in_entryRuleIndexedPropertyAccess5939 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIndexedPropertyAccess5949 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDEX_START_in_ruleIndexedPropertyAccess5985 = new BitSet(new long[]{0x9382BB00E16DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleIndex_in_ruleIndexedPropertyAccess6005 = new BitSet(new long[]{0x0040000000000000L});
+ public static final BitSet FOLLOW_RULE_INDEX_END_in_ruleIndexedPropertyAccess6016 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIndex_in_entryRuleIndex6051 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIndex6061 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_DOT_in_ruleIndex6132 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleIndex6152 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleIndex6181 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleIndex6251 = new BitSet(new long[]{0x00000000C0000000L});
+ public static final BitSet FOLLOW_RULE_DOT_DOT_in_ruleIndex6270 = new BitSet(new long[]{0x9382BB00216DB282L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleIndex6290 = new BitSet(new long[]{0x9382BB00216DB282L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleIndex6321 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleIndex6350 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_rulePrimaryExpression_in_entryRulePrimaryExpression6386 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRulePrimaryExpression6396 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIfExp_in_rulePrimaryExpression6443 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParenthetical_in_rulePrimaryExpression6470 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLiteral_in_rulePrimaryExpression6497 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRange_in_rulePrimaryExpression6553 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArray_in_rulePrimaryExpression6587 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_rulePrimaryExpression6621 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLambda_in_rulePrimaryExpression6649 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleThisProperty_in_rulePrimaryExpression6676 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_THIS_in_rulePrimaryExpression6702 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOR_in_rulePrimaryExpression6730 = new BitSet(new long[]{0x0000000002000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleForBody_in_rulePrimaryExpression6750 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6771 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHILE_in_rulePrimaryExpression6801 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression6821 = new BitSet(new long[]{0x0000000400800000L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rulePrimaryExpression6833 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression6853 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6876 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNTIL_in_rulePrimaryExpression6906 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression6926 = new BitSet(new long[]{0x0000000400800000L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_rulePrimaryExpression6938 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression6958 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression6981 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LOOP_in_rulePrimaryExpression7011 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression7031 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_TRY_in_rulePrimaryExpression7061 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression7081 = new BitSet(new long[]{0x0C00000000000002L});
+ public static final BitSet FOLLOW_RULE_CATCH_in_rulePrimaryExpression7094 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleId_in_rulePrimaryExpression7114 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression7135 = new BitSet(new long[]{0x0800000000000002L});
+ public static final BitSet FOLLOW_RULE_FINALLY_in_rulePrimaryExpression7147 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression7167 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FINALLY_in_rulePrimaryExpression7188 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression7208 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_SWITCH_in_rulePrimaryExpression7241 = new BitSet(new long[]{0x9382BB04216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_rulePrimaryExpression7261 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_rulePrimaryExpression7273 = new BitSet(new long[]{0x6000000800000000L});
+ public static final BitSet FOLLOW_ruleCase_in_rulePrimaryExpression7293 = new BitSet(new long[]{0x6000000800000000L});
+ public static final BitSet FOLLOW_RULE_ELSE_in_rulePrimaryExpression7306 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_rulePrimaryExpression7326 = new BitSet(new long[]{0x0000000800000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_rulePrimaryExpression7339 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_rulePrimaryExpression7368 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBlock_in_entryRuleBlock7403 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleBlock7413 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleBlock7458 = new BitSet(new long[]{0x9382BB08216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleBody_in_ruleBlock7480 = new BitSet(new long[]{0x0000000800000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleBlock7492 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCase_in_entryRuleCase7527 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCase7537 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LEADING_WHEN_in_ruleCase7573 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleCase7593 = new BitSet(new long[]{0x0000000400000040L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleCase7605 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleCase7625 = new BitSet(new long[]{0x0000000400000040L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleCase7648 = new BitSet(new long[]{0x0000000000000802L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleCase7660 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIfExp_in_entryRuleIfExp7697 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIfExp7707 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCondBlock_in_ruleIfExp7753 = new BitSet(new long[]{0x2000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELSE_in_ruleIfExp7765 = new BitSet(new long[]{0x8000000000000000L});
+ public static final BitSet FOLLOW_ruleCondBlock_in_ruleIfExp7785 = new BitSet(new long[]{0x2000000000000002L});
+ public static final BitSet FOLLOW_RULE_ELSE_in_ruleIfExp7799 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleIfExp7819 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleCondBlock_in_entryRuleCondBlock7857 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleCondBlock7867 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_IF_in_ruleCondBlock7909 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleCondBlock7935 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleCondBlock7956 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_entryRuleIdRef7992 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleIdRef8002 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_IDENTIFIER_in_ruleIdRef8046 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_entryRuleId8081 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleId8091 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_IDENTIFIER_in_ruleId8132 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_entryRuleProperty8172 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleProperty8182 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_ruleProperty8274 = new BitSet(new long[]{0x001C000000000000L});
+ public static final BitSet FOLLOW_RULE_DOT_in_ruleProperty8292 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_RULE_DOUBLE_COLON_in_ruleProperty8312 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_RULE_QUESTION_DOT_in_ruleProperty8332 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleId_in_ruleProperty8363 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_ruleProperty8404 = new BitSet(new long[]{0x0020000000000000L});
+ public static final BitSet FOLLOW_RULE_INDEX_START_in_ruleProperty8414 = new BitSet(new long[]{0x9382BB00E16DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleIndex_in_ruleProperty8436 = new BitSet(new long[]{0x0040000000000000L});
+ public static final BitSet FOLLOW_RULE_INDEX_END_in_ruleProperty8447 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleVariable_in_entryRuleVariable8483 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleVariable8493 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleVariable8540 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_AT_SIGIL_in_ruleVariable8558 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_RULE_THIS_in_ruleVariable8575 = new BitSet(new long[]{0x0004000000000000L});
+ public static final BitSet FOLLOW_RULE_DOT_in_ruleVariable8585 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleId_in_ruleVariable8608 = new BitSet(new long[]{0x0004000000000002L});
+ public static final BitSet FOLLOW_RULE_DOT_in_ruleVariable8619 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+ public static final BitSet FOLLOW_ruleId_in_ruleVariable8639 = new BitSet(new long[]{0x0004000000000002L});
+ public static final BitSet FOLLOW_ruleProperty_in_ruleVariable8670 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArray_in_entryRuleAssignableArray8705 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignableArray8715 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_ruleAssignableArray8757 = new BitSet(new long[]{0x0082000020000000L,0x0000000000000003L});
+ public static final BitSet FOLLOW_ruleAssignableArgList_in_ruleAssignableArray8779 = new BitSet(new long[]{0x0000000100000000L});
+ public static final BitSet FOLLOW_RULE_RBRACKET_in_ruleAssignableArray8789 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArgList_in_entryRuleAssignableArgList8824 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignableArgList8834 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArg_in_ruleAssignableArgList8880 = new BitSet(new long[]{0x0000000000000042L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleAssignableArgList8892 = new BitSet(new long[]{0x0082000020000000L,0x0000000000000003L});
+ public static final BitSet FOLLOW_ruleAssignableArg_in_ruleAssignableArgList8912 = new BitSet(new long[]{0x0000000000000042L});
+ public static final BitSet FOLLOW_ruleAssignableArg_in_entryRuleAssignableArg8950 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignableArg8960 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_ruleAssignableArg9006 = new BitSet(new long[]{0x0000000080000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleAssignableArg9023 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_entryRuleAssignable9065 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleAssignable9075 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleVariable_in_ruleAssignable9122 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_ruleAssignable9155 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignableArray_in_ruleAssignable9189 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArg_in_entryRuleArg9225 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArg9235 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleArg9281 = new BitSet(new long[]{0x0000000080000002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleArg9298 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgLine_in_entryRuleArgLine9340 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArgLine9350 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArg_in_ruleArgLine9396 = new BitSet(new long[]{0x0000000000000042L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleArgLine9408 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleArg_in_ruleArgLine9428 = new BitSet(new long[]{0x0000000000000042L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleArgLine9442 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitArgList_in_entryRuleExplicitArgList9479 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleExplicitArgList9489 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArgLine_in_ruleExplicitArgList9535 = new BitSet(new long[]{0x0000000400000802L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleExplicitArgList9548 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleArgLine_in_ruleExplicitArgList9568 = new BitSet(new long[]{0x0000000400000802L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleExplicitArgList9587 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleArgLine_in_ruleExplicitArgList9607 = new BitSet(new long[]{0x0000000800000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleExplicitArgList9618 = new BitSet(new long[]{0x0000000400000802L});
+ public static final BitSet FOLLOW_ruleArgList_in_entryRuleArgList9656 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArgList9666 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitArgList_in_ruleArgList9722 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleArgList9740 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExplicitArgList_in_ruleArgList9760 = new BitSet(new long[]{0x0000000800000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleArgList9771 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleArray_in_entryRuleArray9809 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleArray9819 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_ruleArray9861 = new BitSet(new long[]{0x9382BB05216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleArgList_in_ruleArray9883 = new BitSet(new long[]{0x0000000100000000L});
+ public static final BitSet FOLLOW_RULE_RBRACKET_in_ruleArray9893 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_entryRuleDictionary9928 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictionary9938 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LCURLY_in_ruleDictionary9980 = new BitSet(new long[]{0x0000000400008000L,0x00000000000001E5L});
+ public static final BitSet FOLLOW_ruleDictItems_in_ruleDictionary10002 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
+ public static final BitSet FOLLOW_RULE_RCURLY_in_ruleDictionary10012 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItems_in_entryRuleDictItems10047 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictItems10057 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitDictItems_in_ruleDictItems10113 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleDictItems10131 = new BitSet(new long[]{0x0000000000008000L,0x00000000000001E1L});
+ public static final BitSet FOLLOW_ruleExplicitDictItems_in_ruleDictItems10151 = new BitSet(new long[]{0x0000000800000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleDictItems10162 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExplicitDictItems_in_entryRuleExplicitDictItems10200 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleExplicitDictItems10210 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictLine_in_ruleExplicitDictItems10256 = new BitSet(new long[]{0x0000000400000802L});
+ public static final BitSet FOLLOW_RULE_TERMINATOR_in_ruleExplicitDictItems10269 = new BitSet(new long[]{0x0000000000008000L,0x00000000000001E1L});
+ public static final BitSet FOLLOW_ruleDictLine_in_ruleExplicitDictItems10289 = new BitSet(new long[]{0x0000000400000802L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleExplicitDictItems10308 = new BitSet(new long[]{0x0000000000008000L,0x00000000000001E1L});
+ public static final BitSet FOLLOW_ruleDictLine_in_ruleExplicitDictItems10328 = new BitSet(new long[]{0x0000000800000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleExplicitDictItems10339 = new BitSet(new long[]{0x0000000400000802L});
+ public static final BitSet FOLLOW_ruleDictLine_in_entryRuleDictLine10377 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictLine10387 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItem_in_ruleDictLine10433 = new BitSet(new long[]{0x0000000000000042L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleDictLine10445 = new BitSet(new long[]{0x0000000000008000L,0x00000000000001E1L});
+ public static final BitSet FOLLOW_ruleDictItem_in_ruleDictLine10465 = new BitSet(new long[]{0x0000000000000042L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleDictLine10479 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictItem_in_entryRuleDictItem10516 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictItem10526 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictKey_in_ruleDictItem10581 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000008L});
+ public static final BitSet FOLLOW_RULE_COLON_in_ruleDictItem10593 = new BitSet(new long[]{0x9382BB04216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleDictItem10614 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleDictItem10632 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleDictItem10652 = new BitSet(new long[]{0x0000000800000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleDictItem10663 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleDictKey_in_entryRuleDictKey10702 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleDictKey10712 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLiteral_in_ruleDictKey10759 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleDictKey10786 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLambda_in_entryRuleLambda10821 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLambda10831 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_PARAM_START_in_ruleLambda10868 = new BitSet(new long[]{0x0002000020000100L,0x0000000000000003L});
+ public static final BitSet FOLLOW_ruleParam_in_ruleLambda10889 = new BitSet(new long[]{0x0000000000000140L});
+ public static final BitSet FOLLOW_RULE_COMMA_in_ruleLambda10901 = new BitSet(new long[]{0x0002000020000000L,0x0000000000000003L});
+ public static final BitSet FOLLOW_ruleParam_in_ruleLambda10921 = new BitSet(new long[]{0x0000000000000140L});
+ public static final BitSet FOLLOW_RULE_PARAM_END_in_ruleLambda10936 = new BitSet(new long[]{0x0000000000000200L,0x0000000000000010L});
+ public static final BitSet FOLLOW_RULE_FUNC_ARROW_in_ruleLambda10949 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_RULE_BOUND_FUNC_ARROW_in_ruleLambda10965 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_ruleBlock_in_ruleLambda10986 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParam_in_entryRuleParam11022 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleParam11032 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_ruleParam11080 = new BitSet(new long[]{0x0000000080004002L});
+ public static final BitSet FOLLOW_ruleArray_in_ruleParam11113 = new BitSet(new long[]{0x0000000080004002L});
+ public static final BitSet FOLLOW_ruleDictionary_in_ruleParam11147 = new BitSet(new long[]{0x0000000080004002L});
+ public static final BitSet FOLLOW_ruleThisProperty_in_ruleParam11175 = new BitSet(new long[]{0x0000000080004002L});
+ public static final BitSet FOLLOW_RULE_ELLIPSIS_in_ruleParam11193 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_ruleParam11216 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_ruleParam11236 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNumberLiteral_in_entryRuleNumberLiteral11275 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleNumberLiteral11285 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_NUMBER_in_ruleNumberLiteral11330 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_entryRuleStringLiteral11365 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleStringLiteral11375 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_STRING_in_ruleStringLiteral11420 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBoolLiteral_in_entryRuleBoolLiteral11455 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleBoolLiteral11465 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BOOL_in_ruleBoolLiteral11510 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleJSLiteral_in_entryRuleJSLiteral11545 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleJSLiteral11555 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_JS_in_ruleJSLiteral11600 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRegexLiteral_in_entryRuleRegexLiteral11635 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleRegexLiteral11645 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_REGEX_in_ruleRegexLiteral11690 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleLiteral_in_entryRuleLiteral11725 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleLiteral11735 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleNumberLiteral_in_ruleLiteral11782 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleStringLiteral_in_ruleLiteral11809 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleBoolLiteral_in_ruleLiteral11836 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleJSLiteral_in_ruleLiteral11863 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleRegexLiteral_in_ruleLiteral11890 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleParenthetical_in_entryRuleParenthetical11925 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_EOF_in_entryRuleParenthetical11935 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_ruleParenthetical11983 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_ruleParenthetical11993 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleBody_in_ruleParenthetical12015 = new BitSet(new long[]{0x0000000800000000L});
+ public static final BitSet FOLLOW_RULE_OUTDENT_in_ruleParenthetical12026 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_RULE_RPAREN_in_ruleParenthetical12036 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_ruleParenthetical12060 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleBody_in_ruleParenthetical12081 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
+ public static final BitSet FOLLOW_RULE_RPAREN_in_ruleParenthetical12092 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleId_in_synpred1_InternalCakefile767 = new BitSet(new long[]{0x0000000000004000L});
+ public static final BitSet FOLLOW_RULE_EQUAL_in_synpred1_InternalCakefile773 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
+ public static final BitSet FOLLOW_86_in_synpred1_InternalCakefile775 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_POST_IF_in_synpred3_InternalCakefile2248 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOR_in_synpred4_InternalCakefile2303 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHILE_in_synpred5_InternalCakefile2358 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred6_InternalCakefile2406 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_UNTIL_in_synpred7_InternalCakefile2454 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred8_InternalCakefile2502 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FOROF_in_synpred9_InternalCakefile2877 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred10_InternalCakefile2916 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_FORIN_in_synpred11_InternalCakefile2964 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred12_InternalCakefile3004 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_synpred13_InternalCakefile3043 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_BY_in_synpred14_InternalCakefile3091 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_WHEN_in_synpred15_InternalCakefile3130 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleAssignable_in_synpred17_InternalCakefile3444 = new BitSet(new long[]{0x0000000200004000L});
+ public static final BitSet FOLLOW_set_in_synpred17_InternalCakefile3453 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LOGIC_in_synpred18_InternalCakefile3868 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_COMPARE_in_synpred19_InternalCakefile4037 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_RELATION_in_synpred20_InternalCakefile4206 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_SHIFT_in_synpred21_InternalCakefile4375 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_set_in_synpred22_InternalCakefile4544 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_MATH_in_synpred23_InternalCakefile4753 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_set_in_synpred24_InternalCakefile6101 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleExpression_in_synpred25_InternalCakefile6205 = new BitSet(new long[]{0x00000000C0000000L});
+ public static final BitSet FOLLOW_set_in_synpred25_InternalCakefile6214 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_synpred26_InternalCakefile6515 = new BitSet(new long[]{0x9382BB00216DB280L,0x00000000000003F3L});
+ public static final BitSet FOLLOW_ruleExpression_in_synpred26_InternalCakefile6520 = new BitSet(new long[]{0x00000000C0000000L});
+ public static final BitSet FOLLOW_set_in_synpred26_InternalCakefile6525 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_synpred27_InternalCakefile6571 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LCURLY_in_synpred28_InternalCakefile6605 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_synpred29_InternalCakefile8221 = new BitSet(new long[]{0x001C000000000000L});
+ public static final BitSet FOLLOW_set_in_synpred29_InternalCakefile8226 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_ruleIdRef_in_synpred30_InternalCakefile8384 = new BitSet(new long[]{0x0020000000000000L});
+ public static final BitSet FOLLOW_RULE_INDEX_START_in_synpred30_InternalCakefile8386 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LCURLY_in_synpred32_InternalCakefile9139 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_synpred33_InternalCakefile9173 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LBRACKET_in_synpred36_InternalCakefile11097 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LCURLY_in_synpred37_InternalCakefile11131 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_synpred38_InternalCakefile11974 = new BitSet(new long[]{0x0000000400000000L});
+ public static final BitSet FOLLOW_RULE_INDENT_in_synpred38_InternalCakefile11976 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_RULE_LPAREN_in_synpred39_InternalCakefile12055 = new BitSet(new long[]{0x0000000000000002L});
+
+}
\ No newline at end of file
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/services/CakefileGrammarAccess.java b/example/csep.example.cake/src-gen/csep/example/cake/services/CakefileGrammarAccess.java
new file mode 100644
index 0000000..6e768ee
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/services/CakefileGrammarAccess.java
@@ -0,0 +1,1424 @@
+/*
+* generated by Xtext
+*/
+package csep.example.cake.services;
+
+import com.google.inject.Singleton;
+import com.google.inject.Inject;
+
+import java.util.List;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.service.GrammarProvider;
+import org.eclipse.xtext.service.AbstractElementFinder.*;
+
+import csep.services.CoffeeScriptGrammarAccess;
+
+@Singleton
+public class CakefileGrammarAccess extends AbstractGrammarElementFinder {
+
+
+ public class CakefileElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Cakefile");
+ private final Assignment cTasksAssignment = (Assignment)rule.eContents().get(1);
+ private final RuleCall cTasksTaskDeclarationParserRuleCall_0 = (RuleCall)cTasksAssignment.eContents().get(0);
+
+ //Cakefile:
+ // tasks+=TaskDeclaration*;
+ public ParserRule getRule() { return rule; }
+
+ //tasks+=TaskDeclaration*
+ public Assignment getTasksAssignment() { return cTasksAssignment; }
+
+ //TaskDeclaration
+ public RuleCall getTasksTaskDeclarationParserRuleCall_0() { return cTasksTaskDeclarationParserRuleCall_0; }
+ }
+
+ public class TaskDeclarationElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "TaskDeclaration");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final RuleCall cTASKTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0);
+ private final RuleCall cCALL_STARTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2);
+ private final RuleCall cNameStringLiteralParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0);
+ private final RuleCall cCOMMATerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3);
+ private final Assignment cDescriptionAssignment_4 = (Assignment)cGroup.eContents().get(4);
+ private final RuleCall cDescriptionStringLiteralParserRuleCall_4_0 = (RuleCall)cDescriptionAssignment_4.eContents().get(0);
+ private final RuleCall cCOMMATerminalRuleCall_5 = (RuleCall)cGroup.eContents().get(5);
+ private final Group cGroup_6 = (Group)cGroup.eContents().get(6);
+ private final RuleCall cPARAM_STARTTerminalRuleCall_6_0 = (RuleCall)cGroup_6.eContents().get(0);
+ private final Assignment cOptionsAssignment_6_1 = (Assignment)cGroup_6.eContents().get(1);
+ private final RuleCall cOptionsIdParserRuleCall_6_1_0 = (RuleCall)cOptionsAssignment_6_1.eContents().get(0);
+ private final RuleCall cPARAM_ENDTerminalRuleCall_6_2 = (RuleCall)cGroup_6.eContents().get(2);
+ private final RuleCall cFUNC_ARROWTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7);
+ private final Assignment cBodyAssignment_8 = (Assignment)cGroup.eContents().get(8);
+ private final RuleCall cBodyBlockParserRuleCall_8_0 = (RuleCall)cBodyAssignment_8.eContents().get(0);
+ private final RuleCall cCALL_ENDTerminalRuleCall_9 = (RuleCall)cGroup.eContents().get(9);
+ private final RuleCall cTERMINATORTerminalRuleCall_10 = (RuleCall)cGroup.eContents().get(10);
+
+ /// **
+ // * This grammar may look a bit weird. It accepts two kinds of task declaration:
+ // * - task "foo", "Just foo", -> ...
+ // * - task "foo", "Just foo", (opts) -> ...
+ // *
+ // * They are actually calls of the "task" function with a lambda as its last argument.
+ // * The lambda has no parameter in the first case, and a single parameter ("opts") in the second case.
+ // * So the lexer inserts extra parens
+ // * (CALL_START and CALL_END tokens) to make it a function call.
+ // * / TaskDeclaration:
+ // TASK CALL_START name=StringLiteral COMMA description=StringLiteral COMMA (PARAM_START options=Id PARAM_END)?
+ // FUNC_ARROW body=Block CALL_END TERMINATOR;
+ public ParserRule getRule() { return rule; }
+
+ //TASK CALL_START name=StringLiteral COMMA description=StringLiteral COMMA (PARAM_START options=Id PARAM_END)? FUNC_ARROW
+ //body=Block CALL_END TERMINATOR
+ public Group getGroup() { return cGroup; }
+
+ //TASK
+ public RuleCall getTASKTerminalRuleCall_0() { return cTASKTerminalRuleCall_0; }
+
+ //CALL_START
+ public RuleCall getCALL_STARTTerminalRuleCall_1() { return cCALL_STARTTerminalRuleCall_1; }
+
+ //name=StringLiteral
+ public Assignment getNameAssignment_2() { return cNameAssignment_2; }
+
+ //StringLiteral
+ public RuleCall getNameStringLiteralParserRuleCall_2_0() { return cNameStringLiteralParserRuleCall_2_0; }
+
+ //COMMA
+ public RuleCall getCOMMATerminalRuleCall_3() { return cCOMMATerminalRuleCall_3; }
+
+ //description=StringLiteral
+ public Assignment getDescriptionAssignment_4() { return cDescriptionAssignment_4; }
+
+ //StringLiteral
+ public RuleCall getDescriptionStringLiteralParserRuleCall_4_0() { return cDescriptionStringLiteralParserRuleCall_4_0; }
+
+ //COMMA
+ public RuleCall getCOMMATerminalRuleCall_5() { return cCOMMATerminalRuleCall_5; }
+
+ //(PARAM_START options=Id PARAM_END)?
+ public Group getGroup_6() { return cGroup_6; }
+
+ //PARAM_START
+ public RuleCall getPARAM_STARTTerminalRuleCall_6_0() { return cPARAM_STARTTerminalRuleCall_6_0; }
+
+ //options=Id
+ public Assignment getOptionsAssignment_6_1() { return cOptionsAssignment_6_1; }
+
+ //Id
+ public RuleCall getOptionsIdParserRuleCall_6_1_0() { return cOptionsIdParserRuleCall_6_1_0; }
+
+ //PARAM_END
+ public RuleCall getPARAM_ENDTerminalRuleCall_6_2() { return cPARAM_ENDTerminalRuleCall_6_2; }
+
+ //FUNC_ARROW
+ public RuleCall getFUNC_ARROWTerminalRuleCall_7() { return cFUNC_ARROWTerminalRuleCall_7; }
+
+ //body=Block
+ public Assignment getBodyAssignment_8() { return cBodyAssignment_8; }
+
+ //Block
+ public RuleCall getBodyBlockParserRuleCall_8_0() { return cBodyBlockParserRuleCall_8_0; }
+
+ //CALL_END
+ public RuleCall getCALL_ENDTerminalRuleCall_9() { return cCALL_ENDTerminalRuleCall_9; }
+
+ //TERMINATOR
+ public RuleCall getTERMINATORTerminalRuleCall_10() { return cTERMINATORTerminalRuleCall_10; }
+ }
+
+
+ private CakefileElements pCakefile;
+ private TaskDeclarationElements pTaskDeclaration;
+ private TerminalRule tTASK;
+
+ private final Grammar grammar;
+
+ private CoffeeScriptGrammarAccess gaCoffeeScript;
+
+ @Inject
+ public CakefileGrammarAccess(GrammarProvider grammarProvider,
+ CoffeeScriptGrammarAccess gaCoffeeScript) {
+ this.grammar = internalFindGrammar(grammarProvider);
+ this.gaCoffeeScript = gaCoffeeScript;
+ }
+
+ protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
+ Grammar grammar = grammarProvider.getGrammar(this);
+ while (grammar != null) {
+ if ("csep.example.cake.Cakefile".equals(grammar.getName())) {
+ return grammar;
+ }
+ List grammars = grammar.getUsedGrammars();
+ if (!grammars.isEmpty()) {
+ grammar = grammars.iterator().next();
+ } else {
+ return null;
+ }
+ }
+ return grammar;
+ }
+
+
+ public Grammar getGrammar() {
+ return grammar;
+ }
+
+
+ public CoffeeScriptGrammarAccess getCoffeeScriptGrammarAccess() {
+ return gaCoffeeScript;
+ }
+
+
+ //Cakefile:
+ // tasks+=TaskDeclaration*;
+ public CakefileElements getCakefileAccess() {
+ return (pCakefile != null) ? pCakefile : (pCakefile = new CakefileElements());
+ }
+
+ public ParserRule getCakefileRule() {
+ return getCakefileAccess().getRule();
+ }
+
+ /// **
+ // * This grammar may look a bit weird. It accepts two kinds of task declaration:
+ // * - task "foo", "Just foo", -> ...
+ // * - task "foo", "Just foo", (opts) -> ...
+ // *
+ // * They are actually calls of the "task" function with a lambda as its last argument.
+ // * The lambda has no parameter in the first case, and a single parameter ("opts") in the second case.
+ // * So the lexer inserts extra parens
+ // * (CALL_START and CALL_END tokens) to make it a function call.
+ // * / TaskDeclaration:
+ // TASK CALL_START name=StringLiteral COMMA description=StringLiteral COMMA (PARAM_START options=Id PARAM_END)?
+ // FUNC_ARROW body=Block CALL_END TERMINATOR;
+ public TaskDeclarationElements getTaskDeclarationAccess() {
+ return (pTaskDeclaration != null) ? pTaskDeclaration : (pTaskDeclaration = new TaskDeclarationElements());
+ }
+
+ public ParserRule getTaskDeclarationRule() {
+ return getTaskDeclarationAccess().getRule();
+ }
+
+ //terminal TASK:
+ // "task";
+ public TerminalRule getTASKRule() {
+ return (tTASK != null) ? tTASK : (tTASK = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "TASK"));
+ }
+
+ //Root:
+ // (Body | Block TERMINATOR)?;
+ public CoffeeScriptGrammarAccess.RootElements getRootAccess() {
+ return gaCoffeeScript.getRootAccess();
+ }
+
+ public ParserRule getRootRule() {
+ return getRootAccess().getRule();
+ }
+
+ //Body:
+ // lines+=Line (TERMINATOR lines+=Line?)*;
+ public CoffeeScriptGrammarAccess.BodyElements getBodyAccess() {
+ return gaCoffeeScript.getBodyAccess();
+ }
+
+ public ParserRule getBodyRule() {
+ return getBodyAccess().getRule();
+ }
+
+ //Line:
+ // Stmt | Expression;
+ public CoffeeScriptGrammarAccess.LineElements getLineAccess() {
+ return gaCoffeeScript.getLineAccess();
+ }
+
+ public ParserRule getLineRule() {
+ return getLineAccess().getRule();
+ }
+
+ //Stmt:
+ // ReturnStmt | ThrowStmt | RequireStmt | Comment | ClassDeclaration | statement=STATEMENT;
+ public CoffeeScriptGrammarAccess.StmtElements getStmtAccess() {
+ return gaCoffeeScript.getStmtAccess();
+ }
+
+ public ParserRule getStmtRule() {
+ return getStmtAccess().getRule();
+ }
+
+ //Comment:
+ // comment=HERECOMMENT;
+ public CoffeeScriptGrammarAccess.CommentElements getCommentAccess() {
+ return gaCoffeeScript.getCommentAccess();
+ }
+
+ public ParserRule getCommentRule() {
+ return getCommentAccess().getRule();
+ }
+
+ /// **
+ // * Treat it a special way, because it takes care of import
+ // * / RequireStmt:
+ // => (importedNamespace=Id EQUAL "require") CALL_START uri=STRING CALL_END;
+ public CoffeeScriptGrammarAccess.RequireStmtElements getRequireStmtAccess() {
+ return gaCoffeeScript.getRequireStmtAccess();
+ }
+
+ public ParserRule getRequireStmtRule() {
+ return getRequireStmtAccess().getRule();
+ }
+
+ //ReturnStmt:
+ // {ReturnStmt} RETURN expression=Expression? (POST_IF condition=Expression)?;
+ public CoffeeScriptGrammarAccess.ReturnStmtElements getReturnStmtAccess() {
+ return gaCoffeeScript.getReturnStmtAccess();
+ }
+
+ public ParserRule getReturnStmtRule() {
+ return getReturnStmtAccess().getRule();
+ }
+
+ //ThrowStmt:
+ // THROW exp=Expression;
+ public CoffeeScriptGrammarAccess.ThrowStmtElements getThrowStmtAccess() {
+ return gaCoffeeScript.getThrowStmtAccess();
+ }
+
+ public ParserRule getThrowStmtRule() {
+ return getThrowStmtAccess().getRule();
+ }
+
+ /// **
+ // * Coffeescript is permissive, it can be any expression, but we want to be able to check it as crossref
+ // * / SuperClass:
+ // IdRef | Property;
+ public CoffeeScriptGrammarAccess.SuperClassElements getSuperClassAccess() {
+ return gaCoffeeScript.getSuperClassAccess();
+ }
+
+ public ParserRule getSuperClassRule() {
+ return getSuperClassAccess().getRule();
+ }
+
+ //ClassDeclaration:
+ // {ClassDeclaration} CLASS (body=Block | EXTENDS extend=SuperClass body=Block? | name=(Id | Property) (EXTENDS
+ // extend=SuperClass)? body=Block)?;
+ public CoffeeScriptGrammarAccess.ClassDeclarationElements getClassDeclarationAccess() {
+ return gaCoffeeScript.getClassDeclarationAccess();
+ }
+
+ public ParserRule getClassDeclarationRule() {
+ return getClassDeclarationAccess().getRule();
+ }
+
+ /// **
+ // * FIXME: it should be the same as ClassDeclaration, but it would result in a non-LL decision,
+ // * so I just removed the problematic options (a class body and a name or a superclass is required).
+ // * / AssignedClassDeclaration:
+ // {ClassDeclaration} CLASS (EXTENDS extend=SuperClass body=Block | name=(Id | Property) (EXTENDS extend=SuperClass)?
+ // body=Block)?;
+ public CoffeeScriptGrammarAccess.AssignedClassDeclarationElements getAssignedClassDeclarationAccess() {
+ return gaCoffeeScript.getAssignedClassDeclarationAccess();
+ }
+
+ public ParserRule getAssignedClassDeclarationRule() {
+ return getAssignedClassDeclarationAccess().getRule();
+ }
+
+ //Expression:
+ // Postfix;
+ public CoffeeScriptGrammarAccess.ExpressionElements getExpressionAccess() {
+ return gaCoffeeScript.getExpressionAccess();
+ }
+
+ public ParserRule getExpressionRule() {
+ return getExpressionAccess().getRule();
+ }
+
+ //// right-assoc
+ //// Note: the lexer seems to know it should give a POST_IF token here
+ //Postfix returns Expression: //Assignment postfix+=(PostfixIf | ForBody)?;
+ // Assignment (POST_IF {If.dummy=current} condition=Expression | FOR {For.dummy=current} body=ForBody | WHILE
+ // {While.dummy=current} body=Expression (WHEN when=Expression)? | UNTIL {Until.dummy=current} body=Expression (WHEN
+ // when=Expression)?)?;
+ public CoffeeScriptGrammarAccess.PostfixElements getPostfixAccess() {
+ return gaCoffeeScript.getPostfixAccess();
+ }
+
+ public ParserRule getPostfixRule() {
+ return getPostfixAccess().getRule();
+ }
+
+ //ForBody returns Expression: //FIXME: Range |
+ // OWN? indexes+=ForValue (COMMA indexes+=ForValue)* source=ForSource;
+ public CoffeeScriptGrammarAccess.ForBodyElements getForBodyAccess() {
+ return gaCoffeeScript.getForBodyAccess();
+ }
+
+ public ParserRule getForBodyRule() {
+ return getForBodyAccess().getRule();
+ }
+
+ ////FIXME | Array | Dictionary;
+ //ForValue:
+ // Id;
+ public CoffeeScriptGrammarAccess.ForValueElements getForValueAccess() {
+ return gaCoffeeScript.getForValueAccess();
+ }
+
+ public ParserRule getForValueRule() {
+ return getForValueAccess().getRule();
+ }
+
+ //ForSource:
+ // {ForSource} (FOROF source=Expression (WHEN when=Expression)? | FORIN source=Expression (WHEN when=Expression (BY
+ // by=Expression)? | BY by=Expression (WHEN when=Expression)?)?);
+ public CoffeeScriptGrammarAccess.ForSourceElements getForSourceAccess() {
+ return gaCoffeeScript.getForSourceAccess();
+ }
+
+ public ParserRule getForSourceRule() {
+ return getForSourceAccess().getRule();
+ }
+
+ //Range:
+ // => (LBRACKET start=Expression (DOT_DOT | ELLIPSIS)) end=Expression RBRACKET;
+ public CoffeeScriptGrammarAccess.RangeElements getRangeAccess() {
+ return gaCoffeeScript.getRangeAccess();
+ }
+
+ public ParserRule getRangeRule() {
+ return getRangeAccess().getRule();
+ }
+
+ //Assignment returns Expression:
+ // => (left=Assignable operator=(EQUAL | COMPOUND_ASSIGN)) right=Assigned | LogicOp;
+ public CoffeeScriptGrammarAccess.AssignmentElements getAssignmentAccess() {
+ return gaCoffeeScript.getAssignmentAccess();
+ }
+
+ public ParserRule getAssignmentRule() {
+ return getAssignmentAccess().getRule();
+ }
+
+ //Assigned returns Expression:
+ // Expression | INDENT Expression OUTDENT | AssignedClassDeclaration;
+ public CoffeeScriptGrammarAccess.AssignedElements getAssignedAccess() {
+ return gaCoffeeScript.getAssignedAccess();
+ }
+
+ public ParserRule getAssignedRule() {
+ return getAssignedAccess().getRule();
+ }
+
+ //LogicOp returns Expression:
+ // CompareOp (=> ({BinaryExp.left=current} operator=LOGIC) right=CompareOp)*;
+ public CoffeeScriptGrammarAccess.LogicOpElements getLogicOpAccess() {
+ return gaCoffeeScript.getLogicOpAccess();
+ }
+
+ public ParserRule getLogicOpRule() {
+ return getLogicOpAccess().getRule();
+ }
+
+ //CompareOp returns Expression:
+ // RelationOp (=> ({BinaryExp.left=current} operator=COMPARE) right=RelationOp)*;
+ public CoffeeScriptGrammarAccess.CompareOpElements getCompareOpAccess() {
+ return gaCoffeeScript.getCompareOpAccess();
+ }
+
+ public ParserRule getCompareOpRule() {
+ return getCompareOpAccess().getRule();
+ }
+
+ //RelationOp returns Expression:
+ // ShiftOp (=> ({BinaryExp.left=current} operator=RELATION) right=ShiftOp)*;
+ public CoffeeScriptGrammarAccess.RelationOpElements getRelationOpAccess() {
+ return gaCoffeeScript.getRelationOpAccess();
+ }
+
+ public ParserRule getRelationOpRule() {
+ return getRelationOpAccess().getRule();
+ }
+
+ //ShiftOp returns Expression:
+ // AdditiveOp (=> ({BinaryExp.left=current} operator=SHIFT) right=AdditiveOp)*;
+ public CoffeeScriptGrammarAccess.ShiftOpElements getShiftOpAccess() {
+ return gaCoffeeScript.getShiftOpAccess();
+ }
+
+ public ParserRule getShiftOpRule() {
+ return getShiftOpAccess().getRule();
+ }
+
+ //AdditiveOp returns Expression:
+ // MathOp (=> ({BinaryExp.left=current} operator=(PLUS | MINUS)) right=MathOp)*;
+ public CoffeeScriptGrammarAccess.AdditiveOpElements getAdditiveOpAccess() {
+ return gaCoffeeScript.getAdditiveOpAccess();
+ }
+
+ public ParserRule getAdditiveOpRule() {
+ return getAdditiveOpAccess().getRule();
+ }
+
+ //MathOp returns Expression:
+ // UnaryOp (=> ({BinaryExp.left=current} operator=MATH) right=UnaryOp)*;
+ public CoffeeScriptGrammarAccess.MathOpElements getMathOpAccess() {
+ return gaCoffeeScript.getMathOpAccess();
+ }
+
+ public ParserRule getMathOpRule() {
+ return getMathOpAccess().getRule();
+ }
+
+ //UnaryOp returns Expression:
+ // (UNARY | PLUS | MINUS) Expression | (PLUS_PLUS | MINUS_MINUS) Variable | // FIXME: postfix increment
+ // Application QUESTION?;
+ public CoffeeScriptGrammarAccess.UnaryOpElements getUnaryOpAccess() {
+ return gaCoffeeScript.getUnaryOpAccess();
+ }
+
+ public ParserRule getUnaryOpRule() {
+ return getUnaryOpAccess().getRule();
+ }
+
+ //// Nested function calls and property accesses -- I couldn't come up with a better name
+ //Application:
+ // {SuperCall} (SUPER (CALL_START args=ArgList CALL_END)?) | value=PrimaryExpression features+=FeatureCall*;
+ public CoffeeScriptGrammarAccess.ApplicationElements getApplicationAccess() {
+ return gaCoffeeScript.getApplicationAccess();
+ }
+
+ public ParserRule getApplicationRule() {
+ return getApplicationAccess().getRule();
+ }
+
+ //FeatureCall:
+ // FunctionCall | PropertyAccess;
+ public CoffeeScriptGrammarAccess.FeatureCallElements getFeatureCallAccess() {
+ return gaCoffeeScript.getFeatureCallAccess();
+ }
+
+ public ParserRule getFeatureCallRule() {
+ return getFeatureCallAccess().getRule();
+ }
+
+ //FunctionCall:
+ // {FunctionCall} FUNC_EXIST? CALL_START args=ArgList CALL_END;
+ public CoffeeScriptGrammarAccess.FunctionCallElements getFunctionCallAccess() {
+ return gaCoffeeScript.getFunctionCallAccess();
+ }
+
+ public ParserRule getFunctionCallRule() {
+ return getFunctionCallAccess().getRule();
+ }
+
+ //PropertyAccess:
+ // NamedPropertyAccess | IndexedPropertyAccess;
+ public CoffeeScriptGrammarAccess.PropertyAccessElements getPropertyAccessAccess() {
+ return gaCoffeeScript.getPropertyAccessAccess();
+ }
+
+ public ParserRule getPropertyAccessRule() {
+ return getPropertyAccessAccess().getRule();
+ }
+
+ //ThisProperty:
+ // AT_SIGIL Id;
+ public CoffeeScriptGrammarAccess.ThisPropertyElements getThisPropertyAccess() {
+ return gaCoffeeScript.getThisPropertyAccess();
+ }
+
+ public ParserRule getThisPropertyRule() {
+ return getThisPropertyAccess().getRule();
+ }
+
+ //NamedPropertyAccess:
+ // accessor=(DOT | QUESTION_DOT) name=Id | accessor=DOUBLE_COLON name=Id?;
+ public CoffeeScriptGrammarAccess.NamedPropertyAccessElements getNamedPropertyAccessAccess() {
+ return gaCoffeeScript.getNamedPropertyAccessAccess();
+ }
+
+ public ParserRule getNamedPropertyAccessRule() {
+ return getNamedPropertyAccessAccess().getRule();
+ }
+
+ //IndexedPropertyAccess:
+ // INDEX_START index=Index INDEX_END;
+ public CoffeeScriptGrammarAccess.IndexedPropertyAccessElements getIndexedPropertyAccessAccess() {
+ return gaCoffeeScript.getIndexedPropertyAccessAccess();
+ }
+
+ public ParserRule getIndexedPropertyAccessRule() {
+ return getIndexedPropertyAccessAccess().getRule();
+ }
+
+ //Index:
+ // => dots=(DOT_DOT | ELLIPSIS) end=Expression | => (start=Expression dots=(DOT_DOT | ELLIPSIS)) end=Expression? |
+ // exp=Expression;
+ public CoffeeScriptGrammarAccess.IndexElements getIndexAccess() {
+ return gaCoffeeScript.getIndexAccess();
+ }
+
+ public ParserRule getIndexRule() {
+ return getIndexAccess().getRule();
+ }
+
+ //// Try Range before Array
+ //PrimaryExpression:
+ // IfExp | Parenthetical | Literal | Range | Array | Dictionary | Lambda | ThisProperty | {ThisAlone} THIS | {For} (FOR
+ // loop=ForBody body=Block) | {While} (WHILE loop=Expression (WHEN when=Expression)? body=Block) | {Until} (UNTIL
+ // loop=Expression (WHEN when=Expression)? body=Block) | {Loop} (LOOP body=Block) | {TryCatch} (TRY body=Block (CATCH
+ // exception=Id catchBlock=Block (FINALLY finallyBlock=Block)? | FINALLY finallyBlock=Block)?) | {Switch} (SWITCH
+ // exp=Expression? INDENT cases+=Case* (ELSE elseBlock=Block)? OUTDENT) | IdRef;
+ public CoffeeScriptGrammarAccess.PrimaryExpressionElements getPrimaryExpressionAccess() {
+ return gaCoffeeScript.getPrimaryExpressionAccess();
+ }
+
+ public ParserRule getPrimaryExpressionRule() {
+ return getPrimaryExpressionAccess().getRule();
+ }
+
+ //Block:
+ // {Block} INDENT Body? OUTDENT;
+ public CoffeeScriptGrammarAccess.BlockElements getBlockAccess() {
+ return gaCoffeeScript.getBlockAccess();
+ }
+
+ public ParserRule getBlockRule() {
+ return getBlockAccess().getRule();
+ }
+
+ //// a switch case (called When in coffeescript)
+ //Case:
+ // LEADING_WHEN whens+=Expression (COMMA whens+=Expression)* then=Block TERMINATOR?;
+ public CoffeeScriptGrammarAccess.CaseElements getCaseAccess() {
+ return gaCoffeeScript.getCaseAccess();
+ }
+
+ public ParserRule getCaseRule() {
+ return getCaseAccess().getRule();
+ }
+
+ //IfExp:
+ // blocks+=CondBlock (ELSE blocks+=CondBlock)* (ELSE defaultBlock=Block)?;
+ public CoffeeScriptGrammarAccess.IfExpElements getIfExpAccess() {
+ return gaCoffeeScript.getIfExpAccess();
+ }
+
+ public ParserRule getIfExpRule() {
+ return getIfExpAccess().getRule();
+ }
+
+ //// IF can be 'if' or 'unless'
+ //CondBlock:
+ // operator=IF condition=Expression action=Block;
+ public CoffeeScriptGrammarAccess.CondBlockElements getCondBlockAccess() {
+ return gaCoffeeScript.getCondBlockAccess();
+ }
+
+ public ParserRule getCondBlockRule() {
+ return getCondBlockAccess().getRule();
+ }
+
+ //IdRef:
+ // val=[Id|IDENTIFIER];
+ public CoffeeScriptGrammarAccess.IdRefElements getIdRefAccess() {
+ return gaCoffeeScript.getIdRefAccess();
+ }
+
+ public ParserRule getIdRefRule() {
+ return getIdRefAccess().getRule();
+ }
+
+ //Id:
+ // name=IDENTIFIER;
+ public CoffeeScriptGrammarAccess.IdElements getIdAccess() {
+ return gaCoffeeScript.getIdAccess();
+ }
+
+ public ParserRule getIdRule() {
+ return getIdAccess().getRule();
+ }
+
+ //Property:
+ // => (IdRef accessor=(DOT | DOUBLE_COLON | QUESTION_DOT)) prop=Id // FIXME: property is actually "Expression Accessor"
+ // | => (IdRef INDEX_START) index=Index INDEX_END;
+ public CoffeeScriptGrammarAccess.PropertyElements getPropertyAccess() {
+ return gaCoffeeScript.getPropertyAccess();
+ }
+
+ public ParserRule getPropertyRule() {
+ return getPropertyAccess().getRule();
+ }
+
+ //Variable:
+ // Id | (AT_SIGIL | THIS DOT) Id (DOT props+=Id)* | Property;
+ public CoffeeScriptGrammarAccess.VariableElements getVariableAccess() {
+ return gaCoffeeScript.getVariableAccess();
+ }
+
+ public ParserRule getVariableRule() {
+ return getVariableAccess().getRule();
+ }
+
+ /// ** An array that can be on the left-hand side of an assignment * / AssignableArray:
+ // LBRACKET AssignableArgList RBRACKET;
+ public CoffeeScriptGrammarAccess.AssignableArrayElements getAssignableArrayAccess() {
+ return gaCoffeeScript.getAssignableArrayAccess();
+ }
+
+ public ParserRule getAssignableArrayRule() {
+ return getAssignableArrayAccess().getRule();
+ }
+
+ //AssignableArgList:
+ // args+=AssignableArg (COMMA args+=AssignableArg)*;
+ public CoffeeScriptGrammarAccess.AssignableArgListElements getAssignableArgListAccess() {
+ return gaCoffeeScript.getAssignableArgListAccess();
+ }
+
+ public ParserRule getAssignableArgListRule() {
+ return getAssignableArgListAccess().getRule();
+ }
+
+ //AssignableArg:
+ // arg=Assignable splat?=ELLIPSIS?;
+ public CoffeeScriptGrammarAccess.AssignableArgElements getAssignableArgAccess() {
+ return gaCoffeeScript.getAssignableArgAccess();
+ }
+
+ public ParserRule getAssignableArgRule() {
+ return getAssignableArgAccess().getRule();
+ }
+
+ //Assignable:
+ // Variable | Dictionary | AssignableArray;
+ public CoffeeScriptGrammarAccess.AssignableElements getAssignableAccess() {
+ return gaCoffeeScript.getAssignableAccess();
+ }
+
+ public ParserRule getAssignableRule() {
+ return getAssignableAccess().getRule();
+ }
+
+ /// *
+ // * FIXME: handle more complex assignables
+ // * / Arg:
+ // exp=Expression splat?=ELLIPSIS?;
+ public CoffeeScriptGrammarAccess.ArgElements getArgAccess() {
+ return gaCoffeeScript.getArgAccess();
+ }
+
+ public ParserRule getArgRule() {
+ return getArgAccess().getRule();
+ }
+
+ //ArgLine:
+ // head=Arg (COMMA tail+=Arg)* COMMA?;
+ public CoffeeScriptGrammarAccess.ArgLineElements getArgLineAccess() {
+ return gaCoffeeScript.getArgLineAccess();
+ }
+
+ public ParserRule getArgLineRule() {
+ return getArgLineAccess().getRule();
+ }
+
+ //ExplicitArgList:
+ // lines+=ArgLine (TERMINATOR lines+=ArgLine | INDENT lines+=ArgLine OUTDENT)*;
+ public CoffeeScriptGrammarAccess.ExplicitArgListElements getExplicitArgListAccess() {
+ return gaCoffeeScript.getExplicitArgListAccess();
+ }
+
+ public ParserRule getExplicitArgListRule() {
+ return getExplicitArgListAccess().getRule();
+ }
+
+ //ArgList:
+ // {ArgList} (dummy=ExplicitArgList | INDENT dummy=ExplicitArgList OUTDENT)?;
+ public CoffeeScriptGrammarAccess.ArgListElements getArgListAccess() {
+ return gaCoffeeScript.getArgListAccess();
+ }
+
+ public ParserRule getArgListRule() {
+ return getArgListAccess().getRule();
+ }
+
+ //Array:
+ // LBRACKET ArgList RBRACKET;
+ public CoffeeScriptGrammarAccess.ArrayElements getArrayAccess() {
+ return gaCoffeeScript.getArrayAccess();
+ }
+
+ public ParserRule getArrayRule() {
+ return getArrayAccess().getRule();
+ }
+
+ //// Object in coffeescript
+ //Dictionary:
+ // LCURLY DictItems RCURLY;
+ public CoffeeScriptGrammarAccess.DictionaryElements getDictionaryAccess() {
+ return gaCoffeeScript.getDictionaryAccess();
+ }
+
+ public ParserRule getDictionaryRule() {
+ return getDictionaryAccess().getRule();
+ }
+
+ //DictItems:
+ // {DictItems} (dummy=ExplicitDictItems | INDENT dummy=ExplicitDictItems OUTDENT)?;
+ public CoffeeScriptGrammarAccess.DictItemsElements getDictItemsAccess() {
+ return gaCoffeeScript.getDictItemsAccess();
+ }
+
+ public ParserRule getDictItemsRule() {
+ return getDictItemsAccess().getRule();
+ }
+
+ //ExplicitDictItems:
+ // lines+=DictLine (TERMINATOR lines+=DictLine | INDENT lines+=DictLine OUTDENT)*;
+ public CoffeeScriptGrammarAccess.ExplicitDictItemsElements getExplicitDictItemsAccess() {
+ return gaCoffeeScript.getExplicitDictItemsAccess();
+ }
+
+ public ParserRule getExplicitDictItemsRule() {
+ return getExplicitDictItemsAccess().getRule();
+ }
+
+ //DictLine:
+ // head=DictItem (COMMA tail+=DictItem)* COMMA?;
+ public CoffeeScriptGrammarAccess.DictLineElements getDictLineAccess() {
+ return gaCoffeeScript.getDictLineAccess();
+ }
+
+ public ParserRule getDictLineRule() {
+ return getDictLineAccess().getRule();
+ }
+
+ //DictItem:
+ // {DictItem} key=DictKey (COLON (value=Expression | INDENT value=Expression OUTDENT))?;
+ public CoffeeScriptGrammarAccess.DictItemElements getDictItemAccess() {
+ return gaCoffeeScript.getDictItemAccess();
+ }
+
+ public ParserRule getDictItemRule() {
+ return getDictItemAccess().getRule();
+ }
+
+ //DictKey:
+ // Literal | Id;
+ public CoffeeScriptGrammarAccess.DictKeyElements getDictKeyAccess() {
+ return gaCoffeeScript.getDictKeyAccess();
+ }
+
+ public ParserRule getDictKeyRule() {
+ return getDictKeyAccess().getRule();
+ }
+
+ //// Code in coffeescript
+ //Lambda:
+ // (PARAM_START (params+=Param (COMMA params+=Param)*)? PARAM_END)? (FUNC_ARROW | BOUND_FUNC_ARROW) body=Block;
+ public CoffeeScriptGrammarAccess.LambdaElements getLambdaAccess() {
+ return gaCoffeeScript.getLambdaAccess();
+ }
+
+ public ParserRule getLambdaRule() {
+ return getLambdaAccess().getRule();
+ }
+
+ //Param:
+ // (Id | Array | Dictionary | ThisProperty) (splat?=ELLIPSIS | EQUAL defaultValue=Expression)?;
+ public CoffeeScriptGrammarAccess.ParamElements getParamAccess() {
+ return gaCoffeeScript.getParamAccess();
+ }
+
+ public ParserRule getParamRule() {
+ return getParamAccess().getRule();
+ }
+
+ //NumberLiteral:
+ // {NumberLiteral} NUMBER;
+ public CoffeeScriptGrammarAccess.NumberLiteralElements getNumberLiteralAccess() {
+ return gaCoffeeScript.getNumberLiteralAccess();
+ }
+
+ public ParserRule getNumberLiteralRule() {
+ return getNumberLiteralAccess().getRule();
+ }
+
+ //StringLiteral:
+ // {StringLiteral} STRING;
+ public CoffeeScriptGrammarAccess.StringLiteralElements getStringLiteralAccess() {
+ return gaCoffeeScript.getStringLiteralAccess();
+ }
+
+ public ParserRule getStringLiteralRule() {
+ return getStringLiteralAccess().getRule();
+ }
+
+ //BoolLiteral:
+ // {BoolLiteral} BOOL;
+ public CoffeeScriptGrammarAccess.BoolLiteralElements getBoolLiteralAccess() {
+ return gaCoffeeScript.getBoolLiteralAccess();
+ }
+
+ public ParserRule getBoolLiteralRule() {
+ return getBoolLiteralAccess().getRule();
+ }
+
+ //JSLiteral:
+ // {JSLiteral} JS;
+ public CoffeeScriptGrammarAccess.JSLiteralElements getJSLiteralAccess() {
+ return gaCoffeeScript.getJSLiteralAccess();
+ }
+
+ public ParserRule getJSLiteralRule() {
+ return getJSLiteralAccess().getRule();
+ }
+
+ //RegexLiteral:
+ // {RegexLiteral} REGEX;
+ public CoffeeScriptGrammarAccess.RegexLiteralElements getRegexLiteralAccess() {
+ return gaCoffeeScript.getRegexLiteralAccess();
+ }
+
+ public ParserRule getRegexLiteralRule() {
+ return getRegexLiteralAccess().getRule();
+ }
+
+ //Literal:
+ // NumberLiteral | StringLiteral | BoolLiteral | JSLiteral | RegexLiteral;
+ public CoffeeScriptGrammarAccess.LiteralElements getLiteralAccess() {
+ return gaCoffeeScript.getLiteralAccess();
+ }
+
+ public ParserRule getLiteralRule() {
+ return getLiteralAccess().getRule();
+ }
+
+ //Parenthetical:
+ // => (LPAREN INDENT) content=Body OUTDENT RPAREN | LPAREN content=Body RPAREN;
+ public CoffeeScriptGrammarAccess.ParentheticalElements getParentheticalAccess() {
+ return gaCoffeeScript.getParentheticalAccess();
+ }
+
+ public ParserRule getParentheticalRule() {
+ return getParentheticalAccess().getRule();
+ }
+
+ //// terminals {{{
+ /// * Note: these are only to enable debugging with Antlworks,
+ // * The actual tokens are provided by the lexer.
+ // * The debugger is smart in some cases, and emits different tokens
+ // * for the same character depending on the context.
+ // * For example
+ // * "(1)" -> LPAREN NUMBER RPAREN
+ // * "func()" -> IDENTIFIER CALL_START CALL_END
+ // * But the debugger expects different strings for the tokens,
+ // * so special ones get an additional asterisk:
+ // * LPAREN: '('
+ // * CALL_START: '(*'
+ // *
+ // * To imitate indentation while debugging, use INDENT and OUTDENT, like this
+ // * if maybe {*
+ // * action()
+ // * *}
+ // * else {*
+ // * wait()
+ // * *}
+ // * / // compound terminals at the beginning to they don't get shadowed
+ //terminal ELLIPSIS:
+ // "...";
+ public TerminalRule getELLIPSISRule() {
+ return gaCoffeeScript.getELLIPSISRule();
+ }
+
+ //terminal DOT_DOT:
+ // "..";
+ public TerminalRule getDOT_DOTRule() {
+ return gaCoffeeScript.getDOT_DOTRule();
+ }
+
+ //terminal DOUBLE_COLON:
+ // "::";
+ public TerminalRule getDOUBLE_COLONRule() {
+ return gaCoffeeScript.getDOUBLE_COLONRule();
+ }
+
+ //terminal SHIFT:
+ // "<<" | ">>";
+ public TerminalRule getSHIFTRule() {
+ return gaCoffeeScript.getSHIFTRule();
+ }
+
+ //terminal BOUND_FUNC_ARROW:
+ // "=>";
+ public TerminalRule getBOUND_FUNC_ARROWRule() {
+ return gaCoffeeScript.getBOUND_FUNC_ARROWRule();
+ }
+
+ //terminal FUNC_ARROW:
+ // "->";
+ public TerminalRule getFUNC_ARROWRule() {
+ return gaCoffeeScript.getFUNC_ARROWRule();
+ }
+
+ //terminal COMPARE:
+ // "<" | "==" | ">" | "<=" | ">=" | "!=";
+ public TerminalRule getCOMPARERule() {
+ return gaCoffeeScript.getCOMPARERule();
+ }
+
+ //terminal COMPOUND_ASSIGN:
+ // "+=" | "-=";
+ public TerminalRule getCOMPOUND_ASSIGNRule() {
+ return gaCoffeeScript.getCOMPOUND_ASSIGNRule();
+ }
+
+ //terminal PLUS_PLUS:
+ // "++";
+ public TerminalRule getPLUS_PLUSRule() {
+ return gaCoffeeScript.getPLUS_PLUSRule();
+ }
+
+ //terminal MINUS_MINUS:
+ // "--";
+ public TerminalRule getMINUS_MINUSRule() {
+ return gaCoffeeScript.getMINUS_MINUSRule();
+ }
+
+ //terminal PARAM_END:
+ // "**)";
+ public TerminalRule getPARAM_ENDRule() {
+ return gaCoffeeScript.getPARAM_ENDRule();
+ }
+
+ //terminal PARAM_START:
+ // "(**";
+ public TerminalRule getPARAM_STARTRule() {
+ return gaCoffeeScript.getPARAM_STARTRule();
+ }
+
+ //terminal AT_SIGIL:
+ // "@";
+ public TerminalRule getAT_SIGILRule() {
+ return gaCoffeeScript.getAT_SIGILRule();
+ }
+
+ //terminal BOOL:
+ // "true" | "false" | "undefined" | "null" | "on" | "no" | "yes" | "off";
+ public TerminalRule getBOOLRule() {
+ return gaCoffeeScript.getBOOLRule();
+ }
+
+ //terminal BY:
+ // "by";
+ public TerminalRule getBYRule() {
+ return gaCoffeeScript.getBYRule();
+ }
+
+ //terminal CALL_END:
+ // "*)";
+ public TerminalRule getCALL_ENDRule() {
+ return gaCoffeeScript.getCALL_ENDRule();
+ }
+
+ //terminal CALL_START:
+ // "(*";
+ public TerminalRule getCALL_STARTRule() {
+ return gaCoffeeScript.getCALL_STARTRule();
+ }
+
+ //terminal CATCH:
+ // "catch";
+ public TerminalRule getCATCHRule() {
+ return gaCoffeeScript.getCATCHRule();
+ }
+
+ //terminal CLASS:
+ // "class";
+ public TerminalRule getCLASSRule() {
+ return gaCoffeeScript.getCLASSRule();
+ }
+
+ //terminal COLON:
+ // ":";
+ public TerminalRule getCOLONRule() {
+ return gaCoffeeScript.getCOLONRule();
+ }
+
+ //terminal COLON_SLASH:
+ // "dummy COLON_SLASH";
+ public TerminalRule getCOLON_SLASHRule() {
+ return gaCoffeeScript.getCOLON_SLASHRule();
+ }
+
+ //terminal COMMA:
+ // ",";
+ public TerminalRule getCOMMARule() {
+ return gaCoffeeScript.getCOMMARule();
+ }
+
+ //terminal DOT:
+ // ".";
+ public TerminalRule getDOTRule() {
+ return gaCoffeeScript.getDOTRule();
+ }
+
+ //terminal ELSE:
+ // "else";
+ public TerminalRule getELSERule() {
+ return gaCoffeeScript.getELSERule();
+ }
+
+ //terminal EQUAL:
+ // "=";
+ public TerminalRule getEQUALRule() {
+ return gaCoffeeScript.getEQUALRule();
+ }
+
+ //terminal EXTENDS:
+ // "extends";
+ public TerminalRule getEXTENDSRule() {
+ return gaCoffeeScript.getEXTENDSRule();
+ }
+
+ //terminal FINALLY:
+ // "finally";
+ public TerminalRule getFINALLYRule() {
+ return gaCoffeeScript.getFINALLYRule();
+ }
+
+ //terminal FOR:
+ // "for";
+ public TerminalRule getFORRule() {
+ return gaCoffeeScript.getFORRule();
+ }
+
+ //terminal FORIN:
+ // "in";
+ public TerminalRule getFORINRule() {
+ return gaCoffeeScript.getFORINRule();
+ }
+
+ //terminal FOROF:
+ // "of";
+ public TerminalRule getFOROFRule() {
+ return gaCoffeeScript.getFOROFRule();
+ }
+
+ //terminal FUNC_EXIST:
+ // "dummy FUNC_EXIST";
+ public TerminalRule getFUNC_EXISTRule() {
+ return gaCoffeeScript.getFUNC_EXISTRule();
+ }
+
+ //terminal HERECOMMENT:
+ // "dummy HERECOMMENT";
+ public TerminalRule getHERECOMMENTRule() {
+ return gaCoffeeScript.getHERECOMMENTRule();
+ }
+
+ //terminal IF:
+ // "if" | "unless";
+ public TerminalRule getIFRule() {
+ return gaCoffeeScript.getIFRule();
+ }
+
+ //terminal INDENT:
+ // "{*";
+ public TerminalRule getINDENTRule() {
+ return gaCoffeeScript.getINDENTRule();
+ }
+
+ //terminal INDEX_END:
+ // "*]";
+ public TerminalRule getINDEX_ENDRule() {
+ return gaCoffeeScript.getINDEX_ENDRule();
+ }
+
+ //terminal INDEX_PROTO:
+ // "dummy INDEX_PROTO";
+ public TerminalRule getINDEX_PROTORule() {
+ return gaCoffeeScript.getINDEX_PROTORule();
+ }
+
+ //terminal INDEX_SOAK:
+ // "dummy INDEX_SOAK";
+ public TerminalRule getINDEX_SOAKRule() {
+ return gaCoffeeScript.getINDEX_SOAKRule();
+ }
+
+ //terminal INDEX_START:
+ // "[*";
+ public TerminalRule getINDEX_STARTRule() {
+ return gaCoffeeScript.getINDEX_STARTRule();
+ }
+
+ //terminal JS:
+ // "dummy JS";
+ public TerminalRule getJSRule() {
+ return gaCoffeeScript.getJSRule();
+ }
+
+ //terminal LBRACKET:
+ // "[";
+ public TerminalRule getLBRACKETRule() {
+ return gaCoffeeScript.getLBRACKETRule();
+ }
+
+ //terminal LCURLY:
+ // "dummy LCURLY";
+ public TerminalRule getLCURLYRule() {
+ return gaCoffeeScript.getLCURLYRule();
+ }
+
+ //terminal LEADING_WHEN:
+ // "dummy LEADING_WHEN";
+ public TerminalRule getLEADING_WHENRule() {
+ return gaCoffeeScript.getLEADING_WHENRule();
+ }
+
+ //terminal LOGIC:
+ // "&&" | "||";
+ public TerminalRule getLOGICRule() {
+ return gaCoffeeScript.getLOGICRule();
+ }
+
+ //terminal LOOP:
+ // "loop";
+ public TerminalRule getLOOPRule() {
+ return gaCoffeeScript.getLOOPRule();
+ }
+
+ //terminal LPAREN:
+ // "(";
+ public TerminalRule getLPARENRule() {
+ return gaCoffeeScript.getLPARENRule();
+ }
+
+ //terminal MATH:
+ // "*" | "/";
+ public TerminalRule getMATHRule() {
+ return gaCoffeeScript.getMATHRule();
+ }
+
+ //terminal MINUS:
+ // "-";
+ public TerminalRule getMINUSRule() {
+ return gaCoffeeScript.getMINUSRule();
+ }
+
+ //terminal NEW:
+ // "new";
+ public TerminalRule getNEWRule() {
+ return gaCoffeeScript.getNEWRule();
+ }
+
+ //terminal NUMBER returns ecore::EInt:
+ // "0".."9"+;
+ public TerminalRule getNUMBERRule() {
+ return gaCoffeeScript.getNUMBERRule();
+ }
+
+ //terminal OUTDENT:
+ // "*}";
+ public TerminalRule getOUTDENTRule() {
+ return gaCoffeeScript.getOUTDENTRule();
+ }
+
+ //terminal OWN:
+ // "own";
+ public TerminalRule getOWNRule() {
+ return gaCoffeeScript.getOWNRule();
+ }
+
+ //terminal PLUS:
+ // "+";
+ public TerminalRule getPLUSRule() {
+ return gaCoffeeScript.getPLUSRule();
+ }
+
+ //// practically the same as IF
+ //terminal POST_IF:
+ // "dummy POST_IF";
+ public TerminalRule getPOST_IFRule() {
+ return gaCoffeeScript.getPOST_IFRule();
+ }
+
+ //terminal QUESTION:
+ // "?";
+ public TerminalRule getQUESTIONRule() {
+ return gaCoffeeScript.getQUESTIONRule();
+ }
+
+ //terminal QUESTION_DOT:
+ // "?.";
+ public TerminalRule getQUESTION_DOTRule() {
+ return gaCoffeeScript.getQUESTION_DOTRule();
+ }
+
+ //terminal RBRACKET:
+ // "]";
+ public TerminalRule getRBRACKETRule() {
+ return gaCoffeeScript.getRBRACKETRule();
+ }
+
+ //terminal RCURLY:
+ // "dummy RCURLY";
+ public TerminalRule getRCURLYRule() {
+ return gaCoffeeScript.getRCURLYRule();
+ }
+
+ //terminal REGEX:
+ // "///"->"///";
+ public TerminalRule getREGEXRule() {
+ return gaCoffeeScript.getREGEXRule();
+ }
+
+ //terminal RELATION:
+ // "in" | "of" | "instanceof";
+ public TerminalRule getRELATIONRule() {
+ return gaCoffeeScript.getRELATIONRule();
+ }
+
+ //terminal RETURN:
+ // "return";
+ public TerminalRule getRETURNRule() {
+ return gaCoffeeScript.getRETURNRule();
+ }
+
+ //terminal RPAREN:
+ // ")";
+ public TerminalRule getRPARENRule() {
+ return gaCoffeeScript.getRPARENRule();
+ }
+
+ //terminal STATEMENT:
+ // "break" | "continue" | "debugger";
+ public TerminalRule getSTATEMENTRule() {
+ return gaCoffeeScript.getSTATEMENTRule();
+ }
+
+ //terminal STRING:
+ // "\'\'\'"->"\'\'\'" | "\'" (!"\'" ("\\" ("b" | "t" | "n" | "f" | "r" | "u" | "\"" | "\'" | "\\") | !("\\" | "\'"))*)?
+ // "\'" | "\"\"\""->"\"\"\"" | "\"" (!"\"" ("\\" ("b" | "t" | "n" | "f" | "r" | "u" | "\"" | "\'" | "\\") | !("\\" |
+ // "\""))*)? "\"";
+ public TerminalRule getSTRINGRule() {
+ return gaCoffeeScript.getSTRINGRule();
+ }
+
+ //terminal SUPER:
+ // "super";
+ public TerminalRule getSUPERRule() {
+ return gaCoffeeScript.getSUPERRule();
+ }
+
+ //terminal SWITCH:
+ // "switch";
+ public TerminalRule getSWITCHRule() {
+ return gaCoffeeScript.getSWITCHRule();
+ }
+
+ //terminal TERMINATOR:
+ // "\n"+;
+ public TerminalRule getTERMINATORRule() {
+ return gaCoffeeScript.getTERMINATORRule();
+ }
+
+ //terminal THEN:
+ // "then";
+ public TerminalRule getTHENRule() {
+ return gaCoffeeScript.getTHENRule();
+ }
+
+ //terminal THIS:
+ // "this";
+ public TerminalRule getTHISRule() {
+ return gaCoffeeScript.getTHISRule();
+ }
+
+ //terminal THROW:
+ // "throw";
+ public TerminalRule getTHROWRule() {
+ return gaCoffeeScript.getTHROWRule();
+ }
+
+ //terminal TRY:
+ // "try";
+ public TerminalRule getTRYRule() {
+ return gaCoffeeScript.getTRYRule();
+ }
+
+ //terminal UNARY:
+ // "!" | "~";
+ public TerminalRule getUNARYRule() {
+ return gaCoffeeScript.getUNARYRule();
+ }
+
+ //terminal UNTIL:
+ // "until";
+ public TerminalRule getUNTILRule() {
+ return gaCoffeeScript.getUNTILRule();
+ }
+
+ //terminal WHEN:
+ // "when";
+ public TerminalRule getWHENRule() {
+ return gaCoffeeScript.getWHENRule();
+ }
+
+ //terminal WHILE:
+ // "while";
+ public TerminalRule getWHILERule() {
+ return gaCoffeeScript.getWHILERule();
+ }
+
+ //// These tokens are used only by syntax coloring
+ //terminal LOGIC_WORD:
+ // "and" | "or";
+ public TerminalRule getLOGIC_WORDRule() {
+ return gaCoffeeScript.getLOGIC_WORDRule();
+ }
+
+ //terminal COMPARE_WORD:
+ // "isnt" | "is";
+ public TerminalRule getCOMPARE_WORDRule() {
+ return gaCoffeeScript.getCOMPARE_WORDRule();
+ }
+
+ //terminal UNARY_WORD:
+ // "new" | "do" | "not";
+ public TerminalRule getUNARY_WORDRule() {
+ return gaCoffeeScript.getUNARY_WORDRule();
+ }
+
+ //terminal ML_COMMENT:
+ // "###" !"#"->"###";
+ public TerminalRule getML_COMMENTRule() {
+ return gaCoffeeScript.getML_COMMENTRule();
+ }
+
+ //terminal SL_COMMENT:
+ // "#" !("\n" | "\r")* ("\r"? "\n")?;
+ public TerminalRule getSL_COMMENTRule() {
+ return gaCoffeeScript.getSL_COMMENTRule();
+ }
+
+ //terminal WS:
+ // (" " | "\t")+;
+ public TerminalRule getWSRule() {
+ return gaCoffeeScript.getWSRule();
+ }
+
+ //// Put it at the end, so keywords will be matched earlier
+ //// }}} end of terminals
+ //// vim: set fdm=marker:
+ //terminal IDENTIFIER:
+ // "^"? ("a".."z" | "A".."Z" | "_") ("a".."z" | "A".."Z" | "_" | "0".."9")*;
+ public TerminalRule getIDENTIFIERRule() {
+ return gaCoffeeScript.getIDENTIFIERRule();
+ }
+}
diff --git a/example/csep.example.cake/src-gen/csep/example/cake/validation/AbstractCakefileJavaValidator.java b/example/csep.example.cake/src-gen/csep/example/cake/validation/AbstractCakefileJavaValidator.java
new file mode 100644
index 0000000..713a2b7
--- /dev/null
+++ b/example/csep.example.cake/src-gen/csep/example/cake/validation/AbstractCakefileJavaValidator.java
@@ -0,0 +1,20 @@
+/*
+* generated by Xtext
+*/
+package csep.example.cake.validation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.ecore.EPackage;
+
+public class AbstractCakefileJavaValidator extends csep.validation.CoffeeScriptJavaValidator {
+
+ @Override
+ protected List getEPackages() {
+ List result = new ArrayList();
+ result.add(csep.example.cake.cakefile.CakefilePackage.eINSTANCE);
+ return result;
+ }
+
+}
diff --git a/example/csep.example.cake/src/csep/example/cake/GenerateCakefile.mwe2 b/example/csep.example.cake/src/csep/example/cake/GenerateCakefile.mwe2
index 69fc2ae..532e9b4 100644
--- a/example/csep.example.cake/src/csep/example/cake/GenerateCakefile.mwe2
+++ b/example/csep.example.cake/src/csep/example/cake/GenerateCakefile.mwe2
@@ -14,7 +14,7 @@ Workflow {
scanClassPath = true
platformUri = "${runtimeProject}/.."
//registerGenModelFile = "platform:/resource/org.eclipse.xtext.xbase/model/Xbase.genmodel"
- registerGenModelFile = "platform:/resource/csep/csep/CoffeeScript.genmodel"
+ registerGenModelFile = "platform:/resource/csep/src-gen/csep/CoffeeScript.genmodel"
}
component = DirectoryCleaner {
diff --git a/example/csep.example.cake/xtend-gen/csep/example/cake/generator/.gitignore b/example/csep.example.cake/xtend-gen/csep/example/cake/generator/.gitignore
new file mode 100644
index 0000000..59b4a82
--- /dev/null
+++ b/example/csep.example.cake/xtend-gen/csep/example/cake/generator/.gitignore
@@ -0,0 +1,2 @@
+/.CakefileGenerator.java._trace
+/CakefileGenerator.java
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..fb01d81
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,151 @@
+
+
+ 4.0.0
+
+ csep
+ parent
+ 0.4.0-SNAPSHOT
+ pom
+
+
+ coffeescript-eclipse (parent)
+
+ CoffeeScript Editor for Eclipse
+
+
+ Nodeclipse organization
+ http://www.nodeclipse.org/
+
+
+
+ https://github.com/nodeclipse/coffeescript-eclipse/
+ scm:git:https://github.com/Nodeclipse/coffeescript-eclipse.git
+ scm:git:https://github.com/Nodeclipse/coffeescript-eclipse.git
+
+
+ GitHub
+ https://github.com/nodeclipse/coffeescript-eclipse/issues
+
+
+ Travis CI
+ http://travis-ci.org/Nodeclipse/coffeescript-eclipse
+
+
+
+ PaulVI
+ Paul Verest
+ paul.verest@live.com
+
+ Developer
+
+ +8
+
+
+
+
+
+
+
+ 3.0
+
+
+
+ 0.18.1
+ UTF-8
+ UTF-8
+
+
+
+ csep
+ csep.ui
+
+ csep.tests
+ csep.feature
+ csep.site
+
+
+
+
+ kepler
+ p2
+ http://download.eclipse.org/releases/kepler
+
+
+ xtext
+ p2
+ http://download.eclipse.org/modeling/tmf/xtext/updates/composite/releases/
+
+
+
+
+
+
+ org.eclipse.tycho
+ tycho-maven-plugin
+ ${tycho-version}
+ true
+
+
+ org.eclipse.tycho
+ tycho-compiler-plugin
+ ${tycho-version}
+
+ 1.6
+ 1.6
+
+
+
+
+ org.eclipse.tycho
+ target-platform-configuration
+ ${tycho-version}
+
+
+
+ linux
+ gtk
+ x86
+
+
+ linux
+ gtk
+ x86_64
+
+
+ win32
+ win32
+ x86
+
+
+ win32
+ win32
+ x86_64
+
+
+ macosx
+ cocoa
+ x86_64
+
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-site-plugin
+ 3.3
+
+
+ org.apache.maven.doxia
+ doxia-module-markdown
+ 1.4
+
+
+
+
+
+
+
+
+